C++——类模板相关知识

本文章将对类模板的相关内容进行说明，如有不足，欢迎指正。

类模板的知识点可以分为以下几点：

 1.  类模板
 2. 类模板中成员方法的模板
 3. 类模板中成员方法的模板的特例化
 4. 拷贝构造函数的模板和特例化

 

类模板具有以下特征：

1. 类模板如果不使用，则不会进行实例化

2. 类模板中成员方法的模板特例化不允许在类外实现，因为其绝对依赖于模板

补充：

代理：一个类的成员是另一个类成员的子集。
模板类型列表中可以传递：类型  class  typename
                                           整型常量（int char short long一般为不带小数的）10 20
                                           模板
函数模板  实例化的时候可以不加类型参数
类模板    实例化的时候必须加类型参数
模板具有类型自推功能
利用模板的类型自推功能，推演出参数类型，实例化类模板

 

详细内容请参考以下代码

代码示例1：

//用类模板实现数组的增删改查
template <typename T>
class Carry
{
private:
	T* _arr;
	int _len;
	int _sizeVal;

public:
	Carry(int resize = 2) //resize是给的默认值
	{
		cout<<"Carry(int resize = 2)"<<endl;
		_arr = new T [resize];
		_len = resize;
		_sizeVal = 0;
	}

	~Carry()
	{
		cout<<"~Carry()"<<endl;
		delete []_arr;
	}

	Carry(const Carry &src)
	{
		cout<<"Carry(const Carry &src)"<<endl;
		_arr = new T[src._len];
		_sizeVal = src._sizeVal;
		_len = src._len;
		copyFrom(src);
	}

	//深拷贝时把原来空间里的值拷贝到新空间里
	void copyFrom(const Carry &src)
	{
		cout<<"void copyFrom(const Carry &src)"<<endl;
		for(int i=0; i<src._sizeVal; i++)
		{
			_arr[i] =  src._arr[i];
		}
	}

	Carry &operator = (const Carry &src)
	{
		cout<<"Carry &operator = (const Carry &src)"<<endl;
		if(&src == this)
		{
			return *this;
		}
		if(_arr != NULL)
		{
			delete []_arr;
		}

		_arr = new T[src._len];
		_sizeVal = src._sizeVal;
		_len = src._len;
		copyFrom(src);
	}

	void pushBack(T val)
	{
		cout<<"void pushBack(T val)"<<endl;
		if(isFull())
		{
			reSize();
		}
		//_arr[_sizeVal] = val;
		//_sizeVal ++;
		_arr[_sizeVal++] = val;
	}

	/*
	void insert(int sit, T val)
	{
		if(isFull())
		{
			reSize();
			return false;
		}
		_len ++;
		return true;
	}
	*/
	bool popBack()
	{
		cout<<"bool popBack()"<<endl;
		if(isEmpty())
		{
			return false;
		}
		_sizeVal --;
		return true;
	}

	/*
	bool deleteSit(int sit)
	{
		if(isEmpty)
		{
			return false;
		}
		sit -= 1;
		_len --;
		return true;
	}
	*/

	T getBack()
	{
		cout<<"T getBack()"<<endl;
		if(isEmpty())
		{
			return T();
		}
		//return _arr[_sizeVal];
		//_sizeVal--;
		return _arr[_sizeVal--];
	}

	
	void show();
/*
	{
		cout<<"void show()"<<endl;
		for(int i=0; i<_sizeVal; i++)
		{
			cout<<_arr[i]<<"  ";
		}
		cout<<endl;
	}
*/
/*
	int find(T val);
	{
		cout<<"int find(T val)"<<endl;
		for(int i=0; i<_sizeVal; i++)
		{
			if(arr[i] == val)
			{
				return i;
			}
		}
		return -1;
	}
*/

	//类模板要带类型参数
	template<typename U>
	int find(U val);
/*
	{
		cout<<"template<typename U> int find(U val)"<<endl;
		for(int i=0; i<_sizeVal; i++)
		{
			if(arr[i] == val)
			{
				return i;
			}
		}
		return -1;
	}
*/

/*	template<>
	int find<char*>(char* val);
	{
		cout<<"	template<> int find<char*>(char* val)"<<endl;
		for(int i=0; i<_len; i++)
		{
			if(strcmp(arr[i], val) == 0)
			{
				return i;
			}
		}
		return -1;
	}
*/

	bool isFull()
	{
		cout<<"bool isFull()"<<endl;
		return _sizeVal == _len;
	}

	bool isEmpty()
	{
		cout<<"bool isEmpty()"<<endl;
		return _sizeVal == 0;
	}

	void reSize()
	{
		cout<<"void reSize()"<<endl;
		T *tmp = new T[_len + (_len >> 1)];

		for(int i=0; i<_len; i++)
		{
			tmp[i] = _arr[i];
		}
			delete[]_arr;
			_arr = tmp;
			_len = _len + (_len >> 1);
	}
};

//在类外实现的类模板
template<typename T>
void Carry<T>::show()
{
	for(int i=0; i<_sizeVal; i++)
	{
		cout<<_arr[i]<<"  ";
	}
	cout<<endl;
}

template<typename T>
template<typename U>
int Carry<T>::find(U val)
{
	for(int i=0; i<_sizeVal; i++)
	{
		if(_arr[i] == val)
		{
			return i;
		}
	}
	return -1;
}

/*
template<typename T>
template<>
int Carry<T>::find<char*>(char* val)
{
	for(int i=0; i<_sizeVal; i++)
	{
		if(strcmp(arr[i], val) == 0)
		{
			return i;
		}
	}
	return -1;
}
*/

int main()
{
	Carry<int> arr1;
	for(int i=0; i<10; i++)
	{
		arr1.pushBack(i);
	}
	int sit = arr1.find(10);
	cout<<sit<<endl;
	arr1.show();

	Carry<char*> arr2;
	arr2.pushBack("hello");
	arr2.pushBack("world");
	arr2.pushBack("sweetygirl");
	char str[] = {'s','w','e','e','t','y','g','i','r','l','\0'};
	sit = arr2.find(str);
	cout<<sit<<endl;
	arr2.show();

	return 0;
}