C++:类模板

零构造/零初始化：
把内存单元全部初始化为0

int main()
{
	
	typedef char * CHAR;
	char *c = CHAR();
	
	int a = int();
	double b = double();
	cout << a << endl;
	cout << b << endl;
	return 0;
}

类模板的特例化:
完全特例化
部分特例化
 

#include<iostream>

using namespace std;

//Node<_vty> 如果在类中 构造函数和析构函数 可以缺省类型参数
//类外以及其他地方不要缺省

template<typename T>
class CLink;
template<typename _Vty>
class Node  //此时Node是一个类模板名  
{
	
public:
	Node<_Vty>(_Vty val=_Vty()):value(val),pnext(NULL)//_Vty val=_Vty() 零构造 零初始化
	{}       //Node<_Vty> 构成类名
	~Node<_Vty>()//析构 
	{}
	 //template<typename E>  //这里的友元是一对多  
	 //friend class CLink;//访问Node
	friend class CLink<_Vty>;//一对一
private:
	_Vty value;//值类型
	Node<_Vty>* pnext;//模板名+类型参数
};

template<typename T>
class CLink
{
public:
	CLink<T>()
	{
		cout << "实例化" << endl;
		phead = new Node<T>();//此时 <T>不可省略  在Node类的类外
	}
	~CLink<T>()
	{
		Node<T>* pCur = phead;
		Node<T>* pnext = pCur;
		while (pCur!=NULL)//pCur->pNext != NULL 最后一个删除不了
		{
			pnext = pCur->pnext;
			delete pCur;
			pCur = pnext;
		}
		phead = NULL;
	}
	void Insert(T val)//头插
	{
		Node<T>* pnewnode = new Node<T>(val);
		pnewnode->pnext = phead->pnext;
		phead ->pnext = pnewnode;
	}
	void Delete(T val)
	{
		Node<T>* pfront = Find(val);
		if (pfront != NULL)
		{
			Node<T>* pCur = pfront->pnext;
			pfront->pnext = pCur->pnext;
			delete pCur;
		}
	}
	void Show()
	{
		Node<T>* pCur = phead->pnext;
		while (pCur != NULL)
		{
			cout << pCur->value<<" ";
			pCur = pCur->pnext;
		}
		cout << endl;
	}
//private:
	
	Node<T>* Find(T val);

	template<typename E>  //提供模板的版本
	Node<E>* Find(E val)
	{
		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* val)
	{
		cout << "函数特例化" << 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>// 类模板名+类型  构成 类名
Node<T>* CLink<T>::Find(T val)
{
	cout << "函数调用" << endl;
	Node<T>* pCur = phead;
	while (pCur->pnext != NULL)//前驱
	{
		if (pCur->pnext->value == val)
		{
			return pCur;
		}
		pCur = pCur->pnext;
	}
	return NULL;
}


/*类模板的实例化，选择性实例化，未调用不实例化*/
int main()
{
	CLink<int> link1;// 板使用时必须指定类型, 不支持推演
	//有两个类的实例化  CLink<int>  Node<int>
	CLink<double> link2;
	CLink<const char *> link3;
	link3.Insert("hello");
	link3.Insert("world");
	link3.Find("hello");
	link3.Find<const char*>("hello");//函数特例化
	//link3.Delete("hello");
	link3.Show();
	return 0;
}