//1.模板定义以关键字template开始，后跟一个模板参数列表，此列表不能为空。编译器用推断出的模板参数来实例化一个特定版本的函数。类型参数前必须使用class或者typename(推荐使用typename)。
template <typename T> bool comp(T t0, T t1){return t0 > t1;}
//2.除了定义类型参数外，还可以在模板中定义非类型参数。一个非类型参数表示一个值(必须是常量表达式,实际使用过程中，最好只使用整形，而不要使用其他类型)而非一个类型，通过特定的类型名而非typename来指定非类型参数。
template<int M> inline int fun(int (&p)[M]){return sizeof p;} //注意inline的位置
int a[10] = {};
int v = fun(a); //v = 40
//3.当编译器遇到一个模板定义时，它并不生成代码。只有当我们实例化出模板的一个特定版本时，编译器才会生成代码。这一特性影响了我们如何组织代码以及错误何时被检测到。
// 与一般代码不同，模板的头文件通常既包含声明，也包含定义。
//4.当调用一个函数模板的时候，编译器通常用函数实参为我们推断模板实参。
// 与函数模板的不同之处是，编译器不能为类模板推断模板参数类型，为了使用类模板，必须在模板名后的尖括号中提供额外信息，用来代替模板参数的模板实参列表(函数模板也能这么做)。
// 由以上可知，类模板的名字不是一个类型名，类模板用来实例化类型，而一个实例化的类型总是包含模板参数的。
// 因为类模板的名字不是类型名，而类模板名字加上尖括号以及显示模板实参才是一个类型名，所以在模板类外定义模板类的成员函数的时候必须以关键字template开始，后接类模板参数列表。
template<typename T>
class CA
{
public:
CA(){}
public:
T GetValue();
void SetValue(T t){value = t;}
private:
T value;
};
template<typename T> T CA<T>::GetValue() {return value;}
CA<int> A;
A.SetValue(10);
int value = A.GetValue(); //value = 10
//5.默认情况下，一个类模板的成员函数只有当程序用到它的时候才进行实例化。如果一个类模板的成员函数没有被用到，则此成员函数将不被实例化。
// 上述特性使得:即使某种类型不能完全符合模板的要求，我们仍能使用该类型实例化类。
//6.当我们使用一个类模板类型时必须提供模板实参，但这个规则有一个例外:在类模板自己的作用域中，我们可以直接使用模板名，而不提供实参。
//7.模板和友员
// 模板类与模板友元函数:
// A.类为模板，友元函数也是模板，且使用的模板参数一致。 则此友元函数仅对相同模板参数的类实例具有特殊访问权限。
// B.类为模板，友元函数不是模板(使用指定模板实参类型的类实例)。 则友元函数只对指定类型的模板参数的类实例具有特殊访问权限。
// C.类为模板，友元函数也是模板，且使用的模板类型参数不一致。 则此友元函数对所有类实例都具有特殊访问权限。
// D.类不是模板，友元函数是模板。 则所有模板类型的友元函数都是对此类具有特殊访问权限。
// 模板类有模板类的友元关系(在A类中声明B类为其友元类)
// a.A类为模板， B类是模板,且A类和B类使用的模板参数一致 则此B类仅对相同模板参数的A类实例具有特殊访问权限。
// b.A类是模板， B类是模板，且A类和B类使用的模板参数不一致。 则所有B类的实例都对A类具有特殊访问权限
// c.A类是模板， B类不是模板。 则B类对所有A类的实例均具有特殊访问权限
// d.A类不是模板，B类是模板,且B类使用了指定模板实参类型。 则只有指定类型的B类实例才对A类具有特殊访问权限
// e.A类不是模板，B类是模板,且B类没有使用固定的模板类型。 则所有B类的实例都对A类具有特殊访问权限
template<typename T>
class CMyTest
{
private:
T value;
public:
T GetValue() {return value;}
/*A结论*/friend void SetVlaue_10(CMyTest<T>& MyTest) {MyTest.value = 10;}
/*结论B*/friend void SetValue_20(CMyTest<int> &MyTest);//注意点:此类型的友员函数不能定义在类的内部，否则会造成重定义
/*结论C*/template<typename X> friend void SetValue(CMyTest/*<T> 这里的<T>可加可不加*/ &temMyTest, X value) {temMyTest.value = value;}
};
void SetValue_20(CMyTest<int> &MyTest) {MyTest.value = 20;}
//前向声明
template<typename T>class CMyTest2;
class CMyTest1
{
public:
void PrintfValueInt() {printf("%d\n", valueInt);}
private:
int valueInt;
/*结论d*/friend class CMyTest2<CMyTest1>;
/*结论e*/template<typename T> friend class CMyTest3; //注意这里的friend的位置
};
template<typename T>
class CMyTest2
{
public:
void SetCMyTest1ValueInt_1000(T& a) {a.valueInt = 1000;}
/*结论a*/friend class CMyTest3<T>;
private:
int value;
};
template<typename T>
class CMyTest3
{
public:
void SetCMyTest1ValueInt_3000(CMyTest1& a) {a.valueInt = 3000;}
void SetValue_10(CMyTest2<T>& temMyTest) {temMyTest.value = 10;}
private:
T value;
/*结论c*/friend class CMyTest4;
};
class CMyTest4
{
public:
template<typename T>void SetValue(CMyTest3<T>& temTest, T value) {temTest.value = value;}
/*结论D*/template<int X> friend void SetValue(CMyTest4 &MyTest) {MyTest.value = X;}
private:
int value;
};
template<typename T>
class CA
{
template<typename X> friend class CB;
private:
int value;
};
template<typename X> class CB
{
template<typename T>
/*结论b*/void Fun(CA<T> a) {a.value = 10;}
};
//8.可以将模板类型参数声明为友员,即使使用内置类型也不会出错。
template<typename T> class CA
{
friend T;
public:
void SetValue(T v){value = v;}
private:
T value;
};
class CB
{
public:
CB(){}
CB(int v) : value(v){}
public:
void Fun(CA<CB>);
public:
int value;
};
void CB::Fun(CA<CB> a) {printf("%d\n", a.value.value);}
CB b;
CA<CB> a;
a.SetValue(10);
b.Fun(a); //输出10
//9.类模板的静态成员:相同类型的实例化后的类共同维护一个类的静态成员。不同实例化的类之间的静态成员互不相关。
//10.模板参数遵循普通的作用域规则，一个模板参数名的可用范围是在其声明后，至模板声明或定义结束前。
// 与任何其他名字一样，模板参数会隐藏外层作用域中声明的相同名字。但是与大多数其他上下文不同，在模板内不能重用模板参数名。
// 由于模板参数名不能重用，所以一个模板参数名在一个特定的模板参数列表中只能出现一次。
//11.考虑在类模板中: T::size_type *p;由于编译器无法掌握T的类型，所以编译器不知道这句话的意思是正在定义一个名为p的指针还是将名为size_type的static数据成员与名为p的变量相乘。
// 默认情况下，C++假定通过作用域运算符访问的名字不是类型。因此，如果我们希望使用一个模板类型参数的类型成员，就必须显示的告诉编译器该名字是一个类型。通过使用关键字typename来实现这一点。
// 由上述结论可知: T::size_type *p;的默认意思是将静态成员size_type和p相乘。而typename T::size_type *p;则是定义了一个T::size_type类型的指针。
template<typename T> typename vector<T>::value_type fun() {return vector<T>::value_type();} //vector<T>::value_type();返回一个类型为T的值初始化的值
string s = fun<string>(); //s = "";
//12.可以为类模板提供默认模板实参。在新标准下，也可以为函数提供默认模板实参(VS2010不支持此项特性)。
// 无论何时使用一个模板，我们都必须在模板名之后加上尖括号。尖括号指出类必须从一个模板实例化而来。特别的，当一个类模板为其所有的模板参数均提供了默认实参，且我们希望使用这些默认实参，则必须在模板名后跟一个空尖括号对。
//13.一个类，无论是模板类还是非模板类，都可以包含本身是模板的成员函数。这种成员称为成员模板。
// 成员模板不能是虚函数。这是因为:编译器在处理一个类的时候，会希望确定其虚函数表，若允许定义成员模板为虚函数，则虚函数表无法在编译时就被确定，而必须根据成员模板的实例化情况确定。所以成员模板不能是虚函数。
// 与类模板的普通函数成员不同，成员函数是函数模板。当我们在类模板外定义一个成员模板的时候，必须同时为类模板和成员模板提供模板参数列表。类模板的参数列表在前，后跟成员自己的参数列表。
template<typename T = int> class CA {public: template<typename X> void fun();};
template<typename T> template<typename X> void CA<T>::fun(){printf("%d, %d\n", sizeof(T), sizeof(X));}
CA<> a;
a.fun<double>(); //输出4， 8
//14.当模板被使用时才会进行实例化这一特性意味着:相同的类实例可能出现在多个源文件中。在大系统中，在多个文件中实例化相同模板带来的开销可能会很严重。
// 通过显示实例化可以来避免上述开销。在一个cpp中定义，在其他所有使用此类实例的cpp中声明。
extern template declaration; //实例化声明
template declaration; //实例化定义，其中declaration是一个类或者是函数声明，其中的模板参数均被模板实参替换。
// 由于编译器在使用一个模板时自动对其实例化，因此实例化声明必须出现在任何使用此实例化版本的代码之前。
// 一个类模板的显示实例化会实例化该模板的所有成员，包括内联的成员函数。当编译器遇见一个显示实例化定义的时候，它不了解程序使用哪些函数，因此与处理类模板的普通实例化不同，编译器会实例化该类的所有成员。
//15.如果一个函数形参的类型使用了模板类型参数，那么它将采用特殊的初始化规则。只有很有限的几种类型转换会自动应用于这些实参。编译器通常不是对实参进行类型转换而是生成一个新的模板实例。
// 能应用于函数模板的类型转换如下:
// A:顶层const无论是在实参还是形参中都会被忽略。
// B:const转换:一个const对象的引用或指针可以接受一个非const对象的引用或指针。
// C:当函数形参不是引用类型的时候，则可以对数组或函数类型的实参应用正常的指针转换。
// 一个模板类型参数可以用作多个函数形参的类型，由于上述类型转换的限制，因此传递给这些形参的实参必须具有相同的类型。如果推断出来的类型不匹配，则调用就是错误的。
// 函数模板可以有普通类型定义的形参。这种函数形参能正常接收对应类型的实参(会进行正常的类型转换，而不需要遵守上述规则)。
//16.在某些情况下，编译器无法推断出模板参数的类型。则每次调用都必须为无法推断的那个形参提供一个显示模板实参。
template<typename T, typename X> T fun(X x) {return T(0);}
int value = fun<int>(10); //value = 0
// 对于模板类型参数已经显示指定了的函数形参，可以进行正常的类型转换
// 当我们希望由用户确定返回类型时，用显示模板实参表示模板函数的返回类型是很有效的，但是在其他情况下，要求显示指定模板实参会给用户带来负担，此时使用尾置返回类型可以有效解决这个问题。
template<typename T> auto fun(T beg)->decltype(*beg) {return *beg;}//接受一个迭代器，返回迭代器所指对象的引用。
//17.标准库的类型转换模板。定义在头文件type_traits中，声明在命名空间std中。
对Mod<T>,其中Mod为: 若T为 则Mod<T>::type为
remove_reference X&或 X&& X
否则 T
add_const X&、const X 、函数 T
否则 const T
add_lvalue_reference X& T
X&& X&
否则 T&
add_rvalue_reference X&、X&& T
否则 T&&
remove_pointer X* X
否则 T
add_pointer X&、X&& X*
否则 T*
make_signed unsigned X X
否则 T
make_unsigned 带符号类型 unsigned X
否则 T
remove_extent X[n] X
否则 T
remove_all_extents X[n1][n2]... X
否则 T
//18.当函数参数是一个函数模板实例的地址时，程序上下文必须满足:对每个模板参数，都能唯一确定其值或类型。
//19.引用折叠和右值引用参数:
// 右值引用参数:当我们将一个左值(如i， int类型)传递给函数的右值引用参数，且此右值引用指向模板类型参数(如T&&)时，编译器推断模板类型参数为实参的左值引用类型。此时编译器推断T的类型为int&，而非int。
// T被推断为int&看起来好像意味着上述模板函数的参数应该是一个类型int&的右值引用。通常，我们不能直接定义一个引用的引用，但是通过类型别名或通过模板类型参数间接定义是可以的。
// 引用折叠:如果我们间接的创建了一个引用的引用，则这些引用将发生折叠。
// X& &、X& && 、X&& &都折叠为X&
// X&& &&折叠为X&&
// 注意点:引用折叠只能应用于间接创建的引用的引用，如:类型别名或模板参数。
//20.编写接受右值引用参数的模板函数:
template <typename T> void f3(T&& val) {T t = val;} //实际上f3的形参可以接受任意类型的实参
// 在上述函数中t到底是val的拷贝还是val的引用不能确定，应用remove_reference可能有点帮助，但是编写正确的代码仍然异常困难。
// 在实际编程中，右值引用通常应用于两种情况:模板转发其实参，模板被重载。
// 使用右值引用的函数模板通常的重载方式:
template <typename T> void f(T&&); //绑定到非const右值
template <typename T> void f(const T&); //绑定左值和const右值
// std::move()的定义:
template<class _Ty> inline typename tr1::_Remove_reference<_Ty>::_Type&& move(_Ty&& _Arg){return ((typename tr1::_Remove_reference<_Ty>::_Type&&)_Arg);}
// 转发函数(要保持传入参数的const属性，以及实参是左值还是右值的)的一般定义:
template <typename F, typename T1, typename T2> void flip(F f, T1 &&t1, T2 &&t2){f(std::forward<T1>(t1), std::forward<T2>(t2)};
// std::forward : 定义在头文件utility中，声明在命名空间std中，返回该显示实参类型的右值引用。即, forward<T>的返回类型为T&&。
//21.如果涉及函数模板，则重载函数的匹配规则会受到以下几方面的影响:
// A:对于一个调用，其候选函数包括所有模板实参推断成功的函数模板实例。
// B:候选的函数模板总是可行的，因为模板实参推断会排除任何不可行的模板。
// C:与往常一样，可行函数按类型转换来排序。
// D:与往常一样，如果恰有一个函数提供比任何其他函数都更好的匹配，则选择此函数。但是如果有多个函数提供同样好的匹配，则:
// 如果同样好的函数中只有一个是非模板函数，则选择此函数。
// 如果同样好的函数中没有非模板函数，而有多个函数模板，且其中一个模板比其他模板更特例化，则选择此模板。否则调用有歧义。
//22.模板特例化:编写单一模板，使之对任何可能的模板实参都是最合适的，都能实例化，这并不总是能办到的。在某些情况下，通用模板的定义对特定类型是不合适的:通用定义可能编译失败或者做的不正确。
// 其他时候，我们也可以利用某些特定的知识来编写更高效的代码，而不是从通用模板实例化。当我们不能使用模板版本时，可以定义类或者函数模板的一个特例化版本。
//23.为了指出我们正在实例化一个模板，应使用关键字template后跟一对空尖括号。空尖括号指出我们将为原模板的所有模板参数提供实参。
template <typename T>void Fun(T t){}
template<> void Fun(int t){} //特例化版本
// 当我们定义一个特例化版本时，函数参数类型必须与一个先前声明的模板中对应的类型匹配，否则会发生编译错误。
// 特例化的本质是实例化一个模板，而非重载它。因此，特例化不影响函数匹配。
// 模板及其特例化版本应该声明在同一个头文件中。所有同名模板的声明应该放在前面，然后是这些模板的特例化版本。
// 与函数模板不同，类模板的特例化不必为所有模板参数提供实参。我们可以只指定一部分而非所有模板参数。一个类模板的部分特例化本身是一个模板。
// 我们可以特例化类的成员而不是类。
//类模板部分特例化
template<typename T0, typename T1>
class CTest
{
};
template<typename T0>
class CTest<T0, int>
{
};
//特例化成员:
template<typename T0, typename T1>
class CTest
{
public:
CTest(T0 t_0, T1 t_1) : t0(t_0), t1(t_1){}
public:
T0 GetT0(){return t0;}
T1 GetT1(){return t1;};
private:
T0 t0;
T1 t1;
};
template<> int CTest<int , int>::GetT1() {return 10;} //特例化成员
CTest<int , int> Test_Int(1, 2);
CTest<double, double> Test_Double(1.1, 2.2);
int value0 = Test_Int.GetT1(); //value0 = 10
double value1 = Test_Double.GetT1(); //value1 = 2.2000000000000002
