c++学习之模板类

template <class Type>
class Queue {
public:
    Queue();                  // default constructor

    Type &front();            // return element from head of Queue
    const Type &front() const;

    void push(const Type &);  // add element to back of Queue
    void pop();               // remove element from head of Queue

    bool empty() const;       // true if no elements in the Queue
private:
    // . . .
};

template <class Type> class Queue;//模板声明
// function template declaration must precede friend declaration in QueueItem
template <class T> std::ostream& operator<<(std::ostream&, const Queue<T>&); 函数声明

template <class Type>
class QueueItem {
    friend class Queue<Type>;
    // . . .
    // needs access to item and next
    friend std::ostream& operator<< <Type> (std::ostream&, const Queue<Type>&);
    // . . .
// private class: no public section
    QueueItem(const Type &t): item(t), next(0) { }
    Type item;           // value stored in this element
    QueueItem *next;     // pointer to next element in the Queue
};
template <class Type>
class Queue {
    // needs access to head
    friend std::ostream& operator<< <Type> (std::ostream&, const Queue<Type>&);
public:
    // empty Queue
    Queue(): head(0), tail(0) { }
public:
    // construct a Queue from a pair of iterators on some sequence
    template <class It>
    Queue(It beg, It end):   head(0), tail(0) { copy_elems(beg, end); }
    // copy control to manage pointers to QueueItems in the Queue
    Queue(const Queue &Q): head(0), tail(0)
                                  { copy_elems(Q); }
    Queue& operator=(const Queue&);
    ~Queue() { destroy(); }

    // replace current Queue by contents delimited by a pair of iterators
    template <class Iter> void assign(Iter, Iter);
    // rest of Queue class as before

    // return element from head of Queue
    // unchecked operation: front on an empty Queue is undefined
    Type& front()             { return head->item; }
    const Type &front() const { return head->item; }

    void push(const Type &);      // add element to back of Queue
    void pop();                   // remove element from head of Queue

    bool empty() const {          // true if no elements in the Queue
        return head == 0;
    }
private:
    QueueItem<Type> *head;         // pointer to first element in Queue
    QueueItem<Type> *tail;         // pointer to last element in Queue

    // utility functions used by copy constructor, assignment, and destructor
    void destroy();                // delete all the elements
    void copy_elems(const Queue&); // copy elements from parameter
private:
    // version of copy to be used by assign to copy elements from iterator range
    template <class Iter> void copy_elems(Iter, Iter);
};
void Queue<const char*>::push(const char *const &val)
{
    // allocate a new character array and copy characters from val
    char* new_item = new char[strlen(val) + 1];
    strncpy(new_item, val, strlen(val) + 1);

    // store pointer to newly allocated and initialized element
    QueueItem<const char*> *pt =
        new QueueItem<const char*>(new_item);

    // put item onto existing queue
    if (empty())
        head = tail = pt;   // queue has only one element
    else {
        tail->next = pt;    // add new element to end of queue
        tail = pt;
    }
}

void Queue<const char*>::pop()
{
    // remember head so we can delete it
    QueueItem<const char*> *p = head;
    delete head->item;    // delete the array allocated in push
    head = head->next;    // head now points to next element
    delete p;             // delete old head element
}