C++基础--第四部分:C++的模板

函数模板

// 定义一个函数模板
template<typename T>  // 类型参数列表
bool compare(T a, T b) // compare是一个函数模板，不是函数
{
	return a>b;   
}

int main()
{
	// compare<int> 才是一个函数
	// 函数调用点
	//compare<int>(10, 20);
	//compare<double>(10.5, 20.5);
	
	//compare(20, 30); // 模板实参推演，若符合参数类型的函数代码已经产生，就不用再产生一份相同的代码了
	
	// 模板实参推演
	// 对于某些类型来说，依赖编译器默认实例化的模板代码，代码处理逻辑是错误的
	compare("aaa", "bbb"); // 调用非模板函数，节省编译器处理的时间
	compare<const char*>("aaa", "bbb");
	return 0;
}

• 函数名+类型参数，例如compare才构成一个函数名，在mian函数的函数调用点处，编译器会根据用户指定的参数的类型，从原模版中实例化一份函数代码，实例化后的代码称为模板函数

• 函数模板是不进行编译的，但是实例化出的模板函数是要进行编译的

• 模板的实参推演：根据传入的实参，推导出生产的模板函数的参数是什么类型

// 这里没有显式指定参数类型，编译器根据传入的实参类型，推演出T的类型，并进行模板的实例化
compare(20, 30);

当然，如果此前模板已经实例化出合适的模板函数compare，那么就不会再进行实例化

• 模板的特例化—>不是编译器提供的模板函数，是开发者手动提供的

对于某些类型来说，依赖编译器默认实例化的模板代码，代码处理逻辑是错误的

template<>
bool compare<const char*>(const char* a, const char* b)
{
	cout << "compare<const char*>" << endl;
    // return a>b; 编译器默认实例化的模板代码的处理逻辑
	return strcmp(a, b) > 0;
}

int main()
{
    compare<const char*>("aaa", "bbb");
}

根据上面的代码，如果参数类型T是const char*类型，那么依赖编译器默认实例化的模板代码，将会执行的是两个字符串地址的大小比较，而这种比较对于字符串类型来说显然是错误的！！这里，我们就需要手动添加一份模板的实例化来进行相应的处理, 注意依然要写template，虽然是手动添加，但它依然是模板的实例化！！

• 非模板函数—普通函数

// 1. 函数模板
template<typename T> // 定义一个模板参数列表, T是类型参数，用来接收类型
bool compare(T a, T b) // compare是一个函数模板
{//函数模板{}中的类型不进行编译，根本不知道实际的类型
	cout << "template compare" << endl;
	return a > b;
}

// 2. 模板的特例化
// 针对compare函数模板,提供const char* 类型的特例化版本
template<>
bool compare<const char*>(const char* a, const char* b)
{
	cout << "compare<const char*>" << endl;
	return strcmp(a, b) > 0;
}

// 3. 非模板函数---普通函数
bool compare(const char* a, const char* b)
{
	cout << "normal compare" << endl;
	return strcmp(a, b) > 0;
}

谈到模板函数以及非模板函数的重载关系时，严格来说，两者并不符合重载的条件，因为对于模板函数来说模板名+指定的类型参数才是函数名，例如compare才是函数名，而对于非模板函数来说，compare就是函数名，而函数重载指的是函数名相同，但是参数列表不同的

int main()
{
    compare("aaa", "bbb");// 不会进行实参推演
    compare<const char*>("aaa", "bbb");
    return 0;
}

此外，如果定义了非模板函数，当我们调用compare(“aaa”, “bbb”)函数时，编译器会优先找非模板函数，这样也就不用进行实参推演了,如果没有定义相应的非模板函数，则编译器会进行实参推演，然后看是否用户手动提供了该类型的模板特例化，如果还没有就要根据参数类型实例化模板函数。

• 模板代码调用之前，一定要看到模板定义的地方，这样的话，模板才能进行正常实例化，产生能够被编译器编译的代码，所以，模板代码一般都是放在头文件当中的，然后在源文件当中直接进行#include导入头文件

main.cpp

// 模板的声明 
template<typename T>  
bool compare(T a, T b);  // compare<const char*> *UND*,  compare<int> *UND*, compare<double> *UND* 

bool compare(const char* a, const char* b);  // compare *UND*

int main()
{ 
	compare("aaa", "bbb"); // 调用非模板函数，节省编译器处理的时间
	compare<const char*>("aaa", "bbb");
	return 0;
}

test.cpp

template<typename T> // 定义一个模板参数列表, T是类型参数，用来接收类型
bool compare(T a, T b) // compare是一个函数模板
{//函数模板{}中的类型不进行编译，根本不知道实际的类型
	cout << "template compare" << endl;
	return a > b;
}

// 针对compare函数模板,提供const char* 类型的特例化版本
template<>
bool compare<const char*>(const char* a, const char* b)
{
	cout << "compare<const char*>" << endl;
	return strcmp(a, b) > 0;
}

// 非模板函数---普通函数
bool compare(const char* a, const char* b)
{
	cout << "normal compare" << endl;
	return strcmp(a, b) > 0;
}

根据上面的代码，将模板的定义放在test.cpp文件中，然后在main.cpp中进行模板的声明， 还有非模板函数的声明。

在编译的时候，非模板函数会生成对应的UND符号，在链接过程中进行定位，而在函数调用处compare<const char*>(“aaa”, “bbb”);，根据实参类型，编译器也会产生一份模板函数的声明，在编译时生成UND符号，在链接过程中由于模板的特例化是我们手动提供的，所以能够在test.cpp找到对应的定义，但是其他情况下在test.cpp中的模板并不会进行模板的实例化，所以如果我们在main函数中调用compare(10,20);就会在链接阶段出错了。

• 模板的非类型参数都是常量，只能使用而不能修改（必须是整数/地址/引用类型）

template<typename T, int SIZE>
void sort(T* arr) 
{
	for (int i=0;i<SIZE-1;i++) 
	{
		for (int j=0;j<SIZE-1-i;j++) 
		{
			if (arr[j] > arr[j + 1]) 
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

---

类模板

以下是我编写的一个顺序栈类模板

template<typename T=int> // 默认类型参数
class SeqStack  // SeqStack是模板名  模板名+类型参数列表才是类名
{
public:
	// 除了构造函数和析构函数可以不用写类型参数列表<T>,其他都要写上
	SeqStack<T>(int size=10) // C++开源代码中常用的风格
		:_pStack(new T[size])
		,_top(0)
		,_size(size)
	{}
	~SeqStack<T>() 
	{
		delete[]_pStack; // 释放占用的堆内存
		_pStack = nullptr; 
	}
	SeqStack<T>(const SeqStack<T>& stack)
		// 拷贝构造也有初始化列表
		:_top(stack._top)
		,_size(stack._size)
	{
		// 不要使用memcopy进行浅拷贝-->可能发生浅拷贝错误
		_pStack = new T[_size]; // 申请一块属于对象自己的堆内存
		for (int i=0; i<_top; i++) 
		{
			_pStack[i] = stack._pStack[i];
		}
	}
    
    // 赋值重载函数， 返回引用是为了能够实现连续赋值,比如a=b=c
	SeqStack<T>& operator=(const SeqStack<T>& stack)  
	{
		// 防止自赋值
		if (this == &stack) 
		{
			return *this;
		}
        // 释放当前对象占用的外部资源
		delete[]_pStack;
        
        // 深拷贝
		_top = stack._top;
		_size = stack._size;
		_pStack = new T[_size]; // 申请一块属于对象自己的堆内存
		for (int i = 0; i < _top; i++)
		{
			_pStack[i] = stack._pStack[i];
		}
		return *this;
	}
	void push(const T& val) 
	{
		if (full())
			expand();
		_pStack[_top++] = val;
	}
	void pop() 
	{
		if (empty())
			return;
		_top--;
	}
    
	// 查看栈顶元素
    // 对于只读操作的成员方法都写成const成员方法(普通成员方法，const对象无法调用)
	T top() const 
	{
		/*
		if (empty())
			throw "stack is empty!";  // 抛异常也代表函数逻辑结束
		*/
		return _pStack[_top-1];
	}
    
    // 判满函数
	bool full() const 
	{
		return _top == _size;
	}
    
    // 判空函数
	bool empty() const 
	{
		return _top == 0;
	}

private:
	T* _pStack;		// 指向动态开辟的内存空间的首地址
	int _top;		// 指向栈顶元素位置
	int _size;		// 顺序栈容量
private:
    // 扩容函数
    void expand() 	
	{// 按照原来栈底层数组大小的两倍扩容
		T* ptmp = new T[_size * 2];
		for (int i =0;i<_top;i++) 
		{
			ptmp[i] = _pStack[i];
		}
		delete[]_pStack;
		_pStack = ptmp;
		_size *= 2;
	}
};

• 除了构造函数和析构函数可以不写类型参数列表,其他建议都要写上，毕竟模板名+类型参数列表才是类名

• 编写类模板时，如果要在类外定义成员方法，需要注意：

// 1.加上类名作用域
// 2.类模板中的类型参数T仅作用于类的{}范围内，所以在类外实现成员方法时，还要加上template<typename=T>

template<typename T>
void SeqStack<T>::push(const T& val) 
{
    if (full())
    	expand();
    _pStack[_top++] = val;
}

• 类模板的选择性实例化

  对于调用到的成员方法才会实例化。下面的代码中，编译器会根据指定的类型，实例化模板类SeqStack，并且只会去实例化会调用到的成员方法（构造、析构以及push和pop）

  int main() 
  {
  	// class Seqstack<int>{};这里只实例化了构造函数和析构函数
  	// 类模板的选择性实例化(对于调用到的方法才实例化,节省编译器的工作)
  	SeqStack<int> s1;
  	// SeqStack<> s1;  使用默认类型参数
  	s1.push(20);
  	s1.push(78);
  	s1.push(35);
  	s1.push(12);
  	cout << s1.top() << endl;
  	s1.pop();
  	return 0;
  }