类模板

今天学习了类模板。以对链表的操作为例，分别需要构建一个CLink类模板和Node类模板。

主要分成两种情况来讲，第一种是把两个类模板分开写，第二种是类模板的嵌套。

一、分开的情况

1.部分函数特例化

部分函数特例化==》 完全特例化

较小部分函数不满足某种类的逻辑
部分函数进行特例化
（必须要有模板）

2.完全特例化

较大部门函数不能满足某种类的逻辑

3.代码实现

template<typename T>
class CLink;
template<typename _Vty>
class Node
{
public:
	Node(_Vty val = _Vty()) :value(val), pnext(NULL) //结点类模板的构造
	{}

	~Node()      //结点类模板的析构
	{}
	
	friend class CLink<_Vty>;   //友元
private:
	_Vty value;
	Node<_Vty>* pnext;
};

template<typename T>
class CLink
{
public:
	CLink()      //构造函数
	{
		cout << "template<T> class CLink" << endl;
		phead = new Node<T>();
	}
	~CLink()     //析构函数
	{
		Node<T>* pCur = phead;
		Node<T>* pNext = pCur;
		while (pCur != NULL)
		{
			pNext = pCur->pnext;
			delete pCur;
			pCur = pNext;
		}
		phead = NULL;
	}
	void Insert(T val);           //插入和删除定义在类外了
	void Delete(T val);
	void Show()
	{
		Node<T>* pCur = phead->pnext;
		for (pCur; pCur != NULL; pCur = pCur->pnext)
		{
			cout << pCur->value << " ";
		}
		cout << endl;
	}

	//Node<char*>* Find(char* val);
	Node<T>* Find(T val);     //1.查找函数的普通版本

	template<typename E>
	Node<E>* Find(E val)         //2.查找函数的模板版本
	{
		cout << "Fin<E>::E" << endl;
		Node<E>* pCur = phead;
		while (pCur->pnext != NULL)
		{
			if (pCur->pnext->value == val)
			{
				return pCur;
			}
			pCur = pCur->pnext;
		}
		return NULL;
	}

	template<>
	Node<const char*>* Find<const char*>(const char* val) //3.查找函数的特例化版本：const char*
	{
		cout << "Find<char*>::char*" << endl;
		Node<const char*>* pCur = phead;
		while (pCur->pnext != NULL)
		{
			if (strcmp(pCur->pnext->value,val) == 0)
			{
				return pCur;
			}
			pCur = pCur->pnext;
		}
		return NULL;
	}
private:
	Node<T>* phead;   //头指针
};

template<typename T>
void CLink<T>::Insert(T val)    //插入函数：1.函数名前面需要加作用域（也就是类名），是CLink<T>,不是CLink（模板名）
{                                         //2.在函数前面加上对虚假类型T的定义

	Node<T>* pnewnode = new Node<T>(val);
	pnewnode->pnext = phead->pnext;
	phead->pnext = pnewnode;
}
template<typename T>
Node<T>* CLink<T>::Find(T val)
{
	cout << "Find(T val)" << endl;
	Node<T>* pCur = phead;
	while (pCur->pnext != NULL)
	{
		if (pCur->pnext->value == val)
		{
			return pCur;
		}
		pCur = pCur->pnext;
	}
	return NULL;
}

template<typename T>
void CLink<T>::Delete(T val)
{
	Node<T>* pfront = Find(val);
	if (pfront != NULL)
	{
		Node<T>* pCur = pfront->pnext;
		pfront->pnext = pCur->pnext;
		delete pCur;
	}
}

4.测试 

int main()
{
	CLink<int> link1;
	CLink<double> link2;

	CLink<const char*> link3;//==>类模板中 来实例化 T
	link3.Insert("hello");
	link3.Insert("world");
	link3.Find<const char*>("hello");//函数模板中，来实例化E
	//link3.Delete("hello");
	link3.Show();
	//link1.Insert(10);
	//link1.Show();
	//link1.Delete(10);
	//link1.Show();
	return 0;
}

二、嵌套的情况

1.代码实现

#include<iostream>
using namespace std;

template<typename T>
class CLink
{
public:
	class Node;
	CLink()
	{
		phead = new Node();
	}
	void Insert(T val);
	Node* Find(T val);
	void Show();
	
	~CLink()
	{
		Node* pCur = phead;
		Node* pNext = pCur;
		while (pCur != NULL)
		{
			pNext = pCur->pnext;
			delete pCur;
			pCur = pNext;
		}
		phead = NULL;
	}
private:
	/*
		类型的实例化在访问限定符检查之后进行
	*/
	class Node
	{
	public:
		Node(T data = T()) :value(data), pnext(NULL)
		{}
	public:
		T value;
		Node* pnext;
	};
	Node* phead;
};


template<typename T>
void CLink<T>::Insert(T val)
{
	Node* pnewnode = new Node(val);
	pnewnode->pnext = phead->pnext;
	phead->pnext = pnewnode;
}
/*
	1.定义模板类型参数
	2.指明模板中的类型
*/
template<typename T>
typename CLink<T>::Node* CLink<T>::Find(T val)
{
	Node* pfront = phead;
	while (pfront->pnext != NULL)
	{
		if (pfront->pnext->value == val)
		{
			return pfront;
		}
		pfront = pfront->pnext;
	}
	return NULL;
}

template<typename T>
void CLink<T>::Show()
{
	Node* pCur = phead->pnext;
	while (pCur != NULL)
	{
		cout << pCur->value << " ";
		pCur = pCur->pnext;
	}
	cout << endl;

}

2.测试

int main()
{
	CLink<int> link1;
	for (int i = 0; i < 10; ++i)
	{
		link1.Insert(i + 1);
	}
	link1.Show();
	/*
		类中访问限定符的检查机制是在
	*/
	/*
		不建议这样使用
			破坏封装性
	*/
	auto pnode = link1.Find(8);

	return 0;
}

总结：

1.如何识别一个模板呢，就看名字前面有没有template<typename T>。

2.如果使用第二种情况的话，就少构建一个类模板（Node）。

3.类模板里面有函数模板的构建，同时有函数的重载。

4.记住部分函数特例化（对于确定的某种类型进行，实质上也是完全特例化）与部分特例化的区别。