C++ — 模板

函数模板

函数模板的定义

template<class T>	//模板参数列表    不能使用struct    //自动识别参数类型
template<typename T>        //自动识别参数类型
//typename是用来定义模板参数的关键字，也可以使用class
//template<int T>     //编译出错
T Add(T left, T right)	//函数模板
{
	return left + right;
}
Add(1, 2); 	//模板的实例化

template<class T1, class T2>    //多个类型参数
T2 Add(T1 left, T2 right)
{
	return left + right;
}
Add(1, 2.0); 

函数模板的原理

模板是一个蓝图，本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具，在调用时编译器会根据调用方式生成函数代码
模板匹配规则

1. 一个非模板函数可以和同名的一个函数模板存在，而且该函数模板还可以被实例化为这个非模板函数
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调用时会优先调用非模板函数而不会从该模板产生一个实例，如果模板可以产生一个具有更好的匹配函数，那么将选择模板
3. 模板函数不允许自动类型转化，但普通函数可以自动类型转化

T Add(T left, T right)
{
	return left + right;
}
int Add(int left, int right)    //参数类型符合时，会调用用户自己实现的，且编译器不会再生成
{
    return left + right;
}

函数模板的实例化

多次调用，只生成一份代码

//隐式实例化
Add(1,2);	//对实参进行类型推演，生成处理具体类型的函数
//不会进行隐式类型转化（除数组——>指针、函数名——>函数指针）
 
//显示实例化
Add<int>(1,2);    //确定的参数类型，会进行隐式类型转化 
//显示实例化时，编译器必须生成代码

Add<>(1,2);    //隐式实例化，但也需要生成代码

类模板

类模板的定义

template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};

类模板的实例化

类模板实例化与函数模板实例化不同，类 模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。 在这里，我们实现一个简单的栈，来展示一个类模板。

#define MAXSIZE 10
template<class T>
class STACK
{
public:
	STACK()
	{
		_pStack = new T[10];
		_size = 0;
	}
	void StackPush(T data)
	{
		if (_size == MAXSIZE)
		{
			std::cout << "full" << std::endl;
			return;
		}
		_pStack[_size] = data;
		++_size;
	}
	void StackPop()
	{
		if (_size == 0)
		{
			std::cout << "empty" << std::endl;
			return;
		}
		--_size;;
	}
	T StackTop()
	{
		if (_size == 0)
		{
			std::cout << "empty" << std::endl;
			return -1;
		}
		return _pStack[_size - 1];
	}
	~STACK()
	{
		delete[] _pStack;
		_pStack = nullptr;
		_size = 0;
	}
private:
	T* _pStack;
	int _size;
};


STACK<int> s;

非类型模板

模板参数

类型形参：出现在模板参数列表中，跟在class或者typename之类的参数
非类型形参：用一个常量作为类（函数）模板的一个参数

//非类型模板参数 N    常量
template<class T, size_t N>

//函数
//数组引用，类似于数组指针
void print(const T (&array)[N])    
{ 
)
print(arr);    //编译器会把元素个数传递给N
//类
template<class T, size_t N>
class Array
{
    T _array[N];
}
Array<int, 100> arr;

注意

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的
2. 非类型模板参数必须在编译期就能确认结果

模板的特化

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式

函数模板的特化

必须要先有一个基础的函数模板，那种类型不能处理，特殊化处理该种类型

1. 关键字template后面接一对空的尖括号<>
2. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
3. 用需要特化的类型替换掉所有的T

/*
假设char*需要特殊处理,用char*替换掉所有的T
需要特化类型，将什么类型跟在函数名之后
*/
Template<> 
bool IsEqual<char*>(char*& left, char*& right) 
{    
    if(strcmp(left, right) > 0)        
        return true;        
    return false; 
}
//一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出（简单）。
bool IsEqual(char* left, char* right) 
{    
    if(strcmp(left, right) > 0)        
        return true;        
    return false; 
}
//在模板中,const T pa，const实际是修饰的是pa

类模板的特化

全特化

全特化即是将模板参数类表中所有的参数都确定化

template<class T1, class T2> 
class Data 
{ 
public:    
    Data() 
    {
        cout << "Data<T1, T2>" << endl;
    } 
private:    
    T1 _d1;    
    T2 _d2; 
};
 
//类模板的全特化
template<> 
class Data<int, char> 
{ 
public:    
    Data()
    {
    cout << "Data<int, char>" << endl;
    } 
private:   
    int _d1;    
    char_d2; 
};

偏特化

任何针对模版参数进一步进行条件限制设计的特化版

部分特化

将模板参数类表中的一部分参数特化

//将第二个参数特化
int template <class T1> 
class Data<T1, int> 
{ 
public:    
    Data()
    {
    cout<<"Data<T1, int>" <<endl;
    } 
private:    
    T1 _d1;    
    int _d2; 
};

特化类型

//两个参数偏特化为指针类型 
template <typename T1, typename T2> 
class Data <T1*, T2*>
{ 
public:    
    Data() 
    {
    cout<<"Data<T1*, T2*>" <<endl;
    }    
private:    
    T1 _d1;    
    T2 _d2; 
};
//两个参数偏特化为引用类型 
template <typename T1, typename T2> 
class Data <T1&, T2&> 
{ 
public:    
    Data(const T1& d1, const T2& d2)        
        : _d1(d1)        , _d2(d2)    
    {            
    cout<<"Data<T1&, T2&>" <<endl;    
    }    
private:    
    const T1 & _d1;    
    const T2 & _d2;     
};