C++实验三：模板

一：模板函数

1.一般模板函数

template<class T>
int compare(const T &a,const T &b)
{
	if (a > b)return 1;
	if (a < b)return -1;
	return 0;
}

2.特化模板函数

template<> int compare <const char *> (const char * const &str1, const char * const &str2)
{
	return strcmp(str1,str2);
}

2函数输出

二、模板类Queue或Stack
模板类（Queue，Stack）

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 = 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;
	}
}

三、模板类AutoPtr
构造函数
析构函数
拷贝构造函数
等号、->、*等运算符重载
主函数调用AutoPtr

#ifndef AUTOPTR_H
#define AUTOPTR_H

template<class T>
class AutoPtr
{
public:
	AutoPtr(T* pData);
	AutoPtr(const AutoPtr<T>& h);
	AutoPtr<T>& operator=(const AutoPtr<T>& h);
	T* operator->() {
		return m_pData;
	}
	T& operator*() {
		return *m_pData;
	}
	const T& operator *() const {
		return *m_pData;
	}
	const T* operator-> () const {
		return m_pData;
	}
private:
	void decrUser();
	T* m_pData;
	int* m_nUser;
};
template<class T>
AutoPtr<T>::AutoPtr(T* pData)
{
	m_pData = pData;
	m_nUser = new int(1);
}
template<class T>
AutoPtr<T>::AutoPtr(const AutoPtr<T>& h)
{
	m_pData = h.m_pData;
	m_nUser = h.m_nUser;
	(*m_nUser)++;
}
template<class T>
AutoPtr<T>& AutoPtr<T>:: operator = (const AutoPtr<T>& h)
{
	decrUser();
	m_pData = h.m_pData;
	m_nUser = h.m_nUser;
	(*m_nUser)++;
}
template<class T>
void AutoPtr<T>::decrUser()
{
	--(*m_nUser);
	if ((*m_nUser) == 0) {
		delete m_pData;
		m_pData = 0;
		delete m_nUser;
		m_nUser = 0;
	}
}



#endif