类模板Queue的实现

#include <iostream>
#include <vector>
using namespace std;

template <class Type> class Queue;
template <class T > ostream & operator << (ostream &os, const Queue<T> &);

template <class Type> class QueueItem {
    friend class Queue<Type >;
    friend ostream & operator << <Type> (ostream &os, const Queue<Type> &);
    //private class
    QueueItem(const Type &val) : Item(val), next(0) {}
    Type Item;
    QueueItem<Type > *next;
};

template <class Type> class Queue {
    friend ostream & operator << <Type> (ostream &os, const Queue<Type> &);

public:
    Queue() : head(0), tail(0) {}
    template <class It> Queue(It _beg, It _end) : head(0), tail(0) { copy_elems(_beg, _end); }
    Queue(const Queue<Type> &Q) : head(0), tail(0) { copy_elems(Q); }
    Queue& operator = (const Queue &Q);
    ~Queue() { Destroy(); }
    template <class Iter> void _assign(Iter, Iter);
    Type &_front() { return head->Item; }
    const Type &_front() const { return head->Item; }
    void _push(const Type&);
    void _pop();
    bool _empty() const { return head == 0; }

private:
    QueueItem<Type> *head;
    QueueItem<Type> *tail;
    void Destroy();
    void copy_elems(const Queue<Type> &);
    template <class Iter> void copy_elems(Iter, Iter);
};

template <class Type> Queue<Type>& Queue<Type>::operator = (const Queue<Type> &q)
{
    if (this != &q) {
        head = tail = 0;
        for (QueueItem<Type> *pt = q.head; pt; pt= pt->next) {
            _push(pt->Item);
        }
    }
    return *this;
}

template <class Type> void Queue<Type>::copy_elems(const Queue<Type> &q)
{
    for (QueueItem<Type> *pt = q.head; pt; pt = pt->next) {
        _push(pt->Item);
    }
}
template <class Type> template <class Iter> void Queue<Type>::copy_elems(Iter _beg, Iter _end)
{
    while (_beg != _end) {
        _push(*_beg);
        ++_beg;
    }
}

template <class Type> template <class Iter> void Queue<Type>::_assign(Iter _beg, Iter _end)
{
    head = tail = 0;
    copy_elems(_beg, _end);
}

template <class Type> void Queue<Type>::_push(const Type& val)
{
    QueueItem<Type> *p = new QueueItem<Type>(val);
    if (_empty()) {
        head = tail = p;
    } else {
        tail->next = p;
        tail = p;
    }
}

template <class Type> void Queue<Type>::_pop()
{
    QueueItem<Type> *p = head;
    head = head->next;
    delete p;
}

template <class Type> ostream & operator << (ostream &os, const Queue<Type> &q)
{
    for (QueueItem<Type> *pt = q.head; pt; pt = pt->next) {
        os << pt->Item << " ";
    }
    os << endl;
    return os;
}

template <class Type> void Queue<Type>::Destroy()
{
    while (!_empty()) _pop();
}


int main()
{
    Queue<int >que;
    que._push(1);
    que._push(2);
    que._push(3);
    que._push(4);
    cout << que;
    que._pop();
    cout << que;
    Queue<int >q2, q1(que);
    cout << q1;
    cout << q2._empty() << endl;
    q2 = q1;
    cout << q2;
    while (!que._empty()) {
        cout << que._front() << endl;
        que._pop();
    }
    vector<int > vet(10, 7);
    for (int i = 0; i < (int)vet.size(); i++) {
        cout << vet[i] << ' ';
    }
    cout << endl;
    que._assign(vet.begin(), vet.end());
    cout << que;
    return 0;
}