C++模板

模板类

QueueItem

template<class Type> class QueueItem 
{
    QueueItem(const Type& t) : item(t), next(0) {}
    Type item;
    QueueItem* next;
    friend class Queue<Type>;
    //输出运算符的重载
    friend ostream& operator<<(ostream& os, const Queue<Type>& q);
public:
    QueueItem<Type>* operator++() 
    {
        return next;
    }
    Type& operator*() {
        return item;
    }
};

成员模板函数

template<class Type> class Queue 
{
public:
    Queue() : head(0), tail(0) {}
    Queue(const Queue& q) : head(0), tail(0) 
    {
        copy_items(q);
    }
    //成员函数模板
    template <class It>
    Queue(It beg, It end) : head(0), tail(0) { copy_items(beg, end); }
    template<class It> void assign(It beg, It end);
    Queue& operator=(const Queue&);
    //析构函数
    ~Queue() { destroy(); }
    Type& front() { return head->item; }
    const Type& front() const { return head->item; }
    //元素入队
    void push(const Type&);
    //队尾元素出队
    void pop();
    //判断是否为空队列
    bool empty() const { return head == 0; }
    //输出符重载（第二个参数表示待输出的队列）
    //（全局）友元函数
    friend ostream& operator<<(ostream& os, const Queue<Type>& q) {
        os << "< ";
        QueueItem<Type>* p;
        for (p = q.head; p; p = p->next) 
        {
            os << p->item << " ";
        }
        os << ">";
        return os;
    }
    const QueueItem<Type>* Head() const { return head; }
    const QueueItem<Type>* End() const { return (tail == NULL) ? NULL : tail->next; }
private:
    QueueItem<Type>* head;
    QueueItem<Type>* tail;
    void destroy();
    void copy_items(const Queue&);
    template<class It>
    void copy_items(It beg, It end);
};

//销毁队列
template<class Type> void Queue<Type>::destroy()
{
    while (!empty()) 
    {
        pop();
    }
}

template<class Type> void Queue<Type>::pop() 
{
    QueueItem<Type>* p = head;
    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;
    }
    else 
    {
        tail->next = pt;
        //元素添加到队列后tail指针指向该元素
        tail = pt;
    }
}
template <class Type>
void Queue<Type>::copy_items(const Queue& orig) 
{
    for (QueueItem<Type>* pt = orig.head; pt; pt = pt->next) 
    {
        push(pt->item);
    }
}
template<class Type> template<class It> void Queue<Type>::assign(It beg, It end)
{
    destroy();
    copy_items(beg, end);
}

template<class Type> template<class It> void Queue<Type>::copy_items(It beg, It end)
{
    while (beg != end) {
        push(*beg);
        ++beg;
    }
}

模板成员函数特化

template < >
void Queue<const char*>::push(const char* const& val)
{
    char* new_item = new char[strlen(val) + 1];
    strncpy(new_item, val, strlen(val) + 1);
    QueueItem < const char*> * pt = new QueueItem < const char*>(new_item);
    if (empty())
    {
        head = tail = pt;
    }
    else
    {
        tail->next = pt;
        tail = pt;
    }
}

template < >
void Queue<const char*>::pop()
{
    QueueItem<const char*>* p = head;
    delete head->item;
    head = head->next;
    delete p;
}

测试程序

queue.h

#ifndef QUEUE_H
#define QUEUE_H
#include <iostream> 
using namespace std;

//定义类模板
template<class Type> class Queue;
template<class Type> class QueueItem 
{
    QueueItem(const Type& t) : item(t), next(0) {}
    Type item;
    QueueItem* next;
    friend class Queue<Type>;
    //输出运算符的重载
    friend ostream& operator<<(ostream& os, const Queue<Type>& q);
public:
    QueueItem<Type>* operator++() 
    {
        return next;
    }
    Type& operator*() {
        return item;
    }
};

template<class Type> class Queue 
{
public:
    Queue() : head(0), tail(0) {}
    Queue(const Queue& q) : head(0), tail(0) 
    {
        copy_items(q);
    }
    //成员函数模板
    template <class It>
    Queue(It beg, It end) : head(0), tail(0) { copy_items(beg, end); }
    template<class It> void assign(It beg, It end);
    Queue& operator=(const Queue&);
    //析构函数
    ~Queue() { destroy(); }
    Type& front() { return head->item; }
    const Type& front() const { return head->item; }
    //元素入队
    void push(const Type&);
    //队尾元素出队
    void pop();
    //判断是否为空队列
    bool empty() const { return head == 0; }
    //输出符重载（第二个参数表示待输出的队列）
    //（全局）友元函数
    friend ostream& operator<<(ostream& os, const Queue<Type>& q) {
        os << "< ";
        QueueItem<Type>* p;
        for (p = q.head; p; p = p->next) 
        {
            os << p->item << " ";
        }
        os << ">";
        return os;
    }
    const QueueItem<Type>* Head() const { return head; }
    const QueueItem<Type>* End() const { return (tail == NULL) ? NULL : tail->next; }
private:
    QueueItem<Type>* head;
    QueueItem<Type>* tail;
    void destroy();
    void copy_items(const Queue&);
    template<class It>
    void copy_items(It beg, It end);
};

//销毁队列
template<class Type> void Queue<Type>::destroy()
{
    while (!empty()) 
    {
        pop();
    }
}

template<class Type> void Queue<Type>::pop() 
{
    QueueItem<Type>* p = head;
    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;
    }
    else 
    {
        tail->next = pt;
        //元素添加到队列后tail指针指向该元素
        tail = pt;
    }
}

template < >
void Queue<const char*>::push(const char* const& val);
template < >
void Queue<const char*>::pop();

template <class Type>
void Queue<Type>::copy_items(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& q)
{
    destroy();
    copy_items(q);
}

template<class Type> template<class It> void Queue<Type>::assign(It beg, It end)
{
    destroy();
    copy_items(beg, end);
}

template<class Type> template<class It> void Queue<Type>::copy_items(It beg, It end)
{
    while (beg != end) {
        push(*beg);
        ++beg;
    }
}
void TestQueue();

#endif  //QUEUE_H

queue.cpp

#include "queue.h"
#include <vector>
#include<cstring>

template < >
void Queue<const char*>::push(const char* const& val)
{
    char* new_item = new char[strlen(val) + 1];
    strncpy(new_item, val, strlen(val) + 1);
    QueueItem < const char*> * pt = new QueueItem < const char*>(new_item);
    if (empty())
    {
        head = tail = pt;
    }
    else
    {
        tail->next = pt;
        tail = pt;
    }
}

template < >
void Queue<const char*>::pop()
{
    QueueItem<const char*>* p = head;
    delete head->item;
    head = head->next;
    delete p;
}

void TestQueue()
{
	Queue<int> qt;
	double d = 3.3;
	qt.push(1);
	qt.push(d);
	qt.push(10);
	cout << qt << endl;

	short a[5] = { 0, 3, 6, 9 };
	Queue<int> qi(a, a + 4);
	cout << qi << endl;

	vector<int> vi(a, a + 4);
	qi.assign(vi.begin(), vi.end());
	cout << qi << endl;
	Queue<const char*> q1;
	q1.push("hi");
	q1.push("I'm");
	q1.push("LiaoNanan");
	cout << q1 << endl;

	Queue<const char*> q2(q1);
	cout << q2 << endl;
}

main.cpp

#include<iostream>
#include "queue.h"

using namespace std;
int main() 
{
    TestQueue();
    return 0;
}

结果