C++模板

模板是C++中泛型编程的基础，一个模板就是一个创建类或函数的公式或者说是代码生成器，当使用模板类型时，编译器会生成特定的类或函数，这个过程发生在编译时。C++的模板属于类型膨胀，是真泛型，而Java里的泛型属于类型擦除，是伪泛型。

模板定义

模板定义以关键字template开始，后跟以个模板参数列表，这是一个逗号分隔的一个或多个模板参数的列表，用尖括号括起来。

template<typename T,typename M>

模板参数表示在类或函数定义中用到的类型或值，在使用模板时，我们显式或隐式指定模板实参，将其绑定到模板参数上。

模板编译

为了生成一个实例化版本，编译器需要掌握函数或类模板成员函数的定义，所以模板的声明和定义应该都放在头文件里，如果是只用于源文件内部则可以不放在头文件。

函数模板

当我们调用一个函数模板时，编译器用函数实参来为我们推断模板实参，然后为我们实例化一个特定版本的函数。下面的代码会实例化出两个不同版本的compare。

template<typename T>
bool compare(const T& value1, const T& value2)
{
	return value1 == value2;
}

int main()
{
	cout << compare(1, 10) << endl;
	cout << compare("11", "11") << endl;
	system("pause");
}

类模板

与函数模板不同，编译器不能为类模板推断模板参数类型，为了使用类模板，我们必须在模板名后的尖括号中提供额外的信息，例如vector。

template<typename T>
class Printer
{
public:
	Printer<T>(T value):value_(value) {};
	void execute() 
	{
		cout << value_ << endl;
	}
private:
	T value_;
};

 
 
int main()
{
	auto printer1 = Printer<int>(100);
	auto printer2 = Printer<double>(123.4);
	auto printer3 = Printer<string>("hello world!");
	printer1.execute();
	printer2.execute();
	printer3.execute();
	system("pause");
}

定义在类模板之外的成员函数必须以关键字template开始，后接类模板参数列表。

template<typename T>
void Printer<T>::execute2()
{
	std::cout << value_ << std::endl;
}

成员函数只有在被用到才会实例化，这一特性使得即使类型不能完全符合类模板要求，我们仍然能用该类型实例化类。下面代码中的printer1虽然不能调用execute()，但是仍然可以实例化并调用其它成员函数。

template<typename T>
class Printer
{
public:
	Printer<T>(T value):value_(value) {};
	void execute() 
	{
		cout << value_ << endl;
	}
	void printAddress()
	{
		cout << &value_ << endl;
	}
private:
	T value_;
};

 
 
int main()
{
	auto printer1 = Printer<vector<int>>({1,2,3});
	//printer1.execute();
	printer1.printAddress();
	system("pause");
}

在类模板自己的作用域中，我们可以直接使用模板名而省略尖括号。

template<typename T>
class Printer
{
public:
	Printer<T>(T value):value_(value) {};
	void execute() 
	{
		cout << value_ << endl;
	}

	Printer& getSelf() { return *this; };
	Printer<T>& getSelf2() { return *this; };
	Printer& getSelf3();
private:
	T value_;
};


//类模板外使用类模板名
template<typename T>
Printer<T>& Printer<T>::getSelf3()
{
	Printer& printer = *this;
	return printer;
}
 
int main()
{
	auto printer1 = Printer<int>(100);
	printer1.getSelf().execute();
	printer1.getSelf2().execute();
	printer1.getSelf3().execute();
	system("pause");
}

类模板的每个实例都有一个独立的静态成员，类似其它成员函数，一个静态成员函数只有在使用时才会实例化。

template<typename T>
class Printer
{
public:
	static int testValue_;
};

template<typename T>
int Printer<T>::testValue_ = 0;
 
int main()
{
	Printer<double>::testValue_ = 100;
	Printer<int>::testValue_ = 101;
	cout << Printer<double>::testValue_ << endl;
	cout << Printer<int>::testValue_ << endl;
	system("pause");
}

非类型模板参数

除了定义类型参数，还可以在模板中定义非类型参数，一个非类型参数表示一个值而非一个类型，我们通过特定的类型名而不是typename来指定非类型模板参数。

非类型模板参数可以是一个整型，或者是一个指向对象或函数类型的指针或引用，非类型模板参数的模板实参必须是常量表达式，从而允许编译器在编译时实例化模板。

template<int N,int M>
int compare(const char (&value1)[N], const char(&value2)[M])
{
	return strcmp(value1,value2);
}

 
int main()
{
	cout << compare("11", "112") << endl;
	system("pause");
}

默认模板实参

就像我们能为函数参数提供默认参数意义，我们也可以为函数和类模板提供默认实参：

template<typename T,typename F=less<int>>
bool compare(const T & value1, const T & value2, F func = F())
{
	return func(value1, value2);
}

template<typename T=int>
class MyClass {
public:
	T value = {};
};

 
int main()
{
	//使用默认模板实参
	compare(111, 2222);
	compare(string("111"), string("2222"), less<string>());

	//使用默认模板实参
	MyClass<> value1;
	MyClass<double> value2;
	value2.value = 3.1416;
	cout << value1.value << endl;
	cout << value2.value << endl;
	system("pause");
}

限制模板参数

C++不像其它语言能显式限制模板参数，例如Java里的extends，Swift里的T:ClassB，好处是我们可以把要使用的成员先写好，模板实例化的时候编译器会判断该类型是否符合条件，不符合则编译失败。

template<typename T>
size_t getSize(const T & value)
{
	return value.size();
}


class MyClass {
public:
	size_t size() const { return 3; }
};

 
int main()
{
	vector<int> value1 = { 1,2,3,4,5 };
	MyClass value2;
	int value3;
	cout <<getSize(value1)<< endl;
	cout << getSize(value2) << endl;
	cout << getSize(value3) << endl;//错误，int没有size方法
	system("pause");
}

控制模板实例化

当多个源文件使用了相同的模板，并提供相同的模板参数时，每个文件都会有该模板的一个实例，为了避免这种额外开销，我们可以使用显式实例化，当编译器遇到extern template时不会在本文件中生成实例化代码，而是从定义处实例化代码，可能有多个extern声明但是只能有一处定义。和普通实例化不同，实例化定义会初始化所有成员，即使我们没有使用该成员。
Example.h

template<typename T>
class MyClass {
public:
	//int getSize() { return value.size(); };
	T value = {};
};

Example.cpp

#include "Example.h"

//定义MyClass<int>
template class MyClass<int>;

main.cpp

//声明MyClass<int>
extern template class MyClass<int>;


int main()
{
	MyClass<int> value;   
	cout << value.value << endl;
	system("pause");
}

指定显式模板实参

函数模板一般会推断模板参数类型，但有时候也需要指定显式模板实参，可以只指定前面的一部分实参，后面的可以让编译器推断。

template <typename T1,typename T2,typename T3>
T1 getResult(T2 value1, T3 value2)
{
	return value1+value2;
}


int main()
{
	cout <<getResult<int>(1,2)<< endl;
	cout << getResult<int>(1.0, 2.2) << endl;
	cout << getResult<string>(string("hello "), string("world!")) << endl;
	system("pause");
}

重载与模板

当有多个重载模板对一个调用提供同样好的匹配时，编译器会选择最特例化的版本，越通用的模板的优先级越低。

对于一个调用，如果一个非函数模板与一个函数模板提供同样好的匹配，则选择非模板版本。