Queue C ++ implementation

# Include "stdafx. H"
# Include <iostream>
# Include <string>
Using namespace STD;

Template <class type> class queue;
Template <class type> class queueitem
{
Public:
Friend class queue <type>;
Queueitem (const type & T): item (t), next (0 ){}
Type item;
Queueitem * next;
};

Template <class type> class queue
{
Public:
Queueitem <type> * head;
Queueitem <type> * tail;
Void destory ();
Void copy_elems (const queue &);

Queue (): Head (0), tail (0 ){}
Queue (const queue & Q): Head (0), tail (0)
{
Copy_elems (Q );
}
Queue & operator = (const queue &);
~ Queue ()
{
Destory ();
}

Type & Front ()
{
Return head-> item;
}

Const type & Front () const
{
Return head-> item;
}
Void push (const type &);
Void POP ();
Bool empty () const
{
Return head = 0;
}
};

Template <class type>
Void queue <type >:: destory ()
{
While (! Empty ())
Pop ();
}
Template <class type>
Void queue <type >:: POP ()
{
Queueitem <type> * P = head;
Cout <p-> item <Endl;
Head = head-> next;
Delete P;
}

Template <class type>
Void queue <type >:: push (const type & Val)
{
Queueitem <type> * PT = new queueitem <type> (VAL );
If (empty ()){
Head = tail = pt;
Cout <tail-> item <Endl;
}
Else
{
Cout <Pt-> item <Endl;
Tail-> next = pt;
Tail = pt;
}
}
Template <class type>
Void queue <type >:: copy_elems (const queue & orig)
{
For (queueitem <type> * PT = orig. Head; PT; Pt = Pt-> next)
Push (Pt-> item );
}

Template <class type>
Queue <type> & queue <type>: Operator = (const queue & orig)
{
Queue <type> * queue = new queue <type>;
For (queueitem <type> * PT = orig. Head; PT; Pt = Pt-> next)
Queue. Push (Pt-> item );

Return * queue;
}

// Main. cpp
Using namespace STD;

Int main ()
{
Int A [5] = {2, 43, 1, 4, 6 };
Queue <int> FQ;
For (INT I = 0; I <5; I ++ ){
FQ. Push (A [I]);
}
// FQ. Pop ();
Return 0;
}