《C++ primer》学习笔记之二十五：template function 的实例化

2.何时实例化：
(1).遇到一个函数调用或取函数地址，如果在普通函数定义中找到了匹配的定义，那么直接用普通的函数
如果遇到显式实例化，那么直接跳到第(3)步
比如：
//te.cpp
void f(int i){ cout << "f(" << i << ")" << endl; }
f(2); //这个调用不会引起实例化template_function

//必须是精确匹配，不需要隐含的转换。下面这个不是精确匹配
f(2.0f); //实例化：void f(float) .

此时就不要实例化了。

(2).如果在普通函数中没有找到精确匹配的，则到显式规格化函数explicit_specialization_template_function中匹配
//声明一个f的显式规格化函数：
//te.h
template <typename T> void f(T t); //声明template_function f
template <> void f<float>(float x); //声明一个f的显式规格化函数。这个必须在f的声明或定义之后
template <> void f(float x); //这样显示规格化也可以（没有<float>了）。因为参数float x已表明template parameter为float
//类推，如果从函数参数中可以推导出template parameter的值，则可以靠后的连续的几个template parameter可以省略，让编译器自己去猜

template <typename T> //定义template_function f
void f(T t){ cout << t << endl; };

//te.cpp
void f(int i){ cout << "f(" << i << ")" << endl; } //普通的函数
template <> void f(float x) //explicit_specializztion_template_function定义
{ cout << "f(" << x << "f)" << endl; }

f(2); //输出：f(2) 这个是普通函数
f(2.0f); //输出：f(2f) 这个即是显式规格化的那位
f(2.0); //输出：double 这个是template_function实例化void f(double)后的输出

与普通函数一样：显式规格化template函数要先在header中声明，然后再在.cpp中定义，否则出现“重复定义”的编译错
不过很奇怪的是，可以在同一个.cpp中定义多次显式规格化template函数，且body各异。不过结果是以第一次的为准。
但不可以在不同的.cpp中定义同一个显示规格化template函数，否则出现“重复定义”的编译错
与普通函数一样：如果显示规格化template函数只声明却没有定义，则会报“定义找不到”的link错

此时的匹配与1中一样，也是精确匹配
(3).如果2也没有找到匹配的函数，则到template_function中匹配
匹配时，找符合调用函数参数的template_function，并用匹配的类型去实例化template_function。怎么匹配，请看3如何实例化
该实例化是隐式实例化
//te.cpp
class ClassA{}
template <class T>
class TemClassB{}

int main()
{
f(2.0); //输出：f(double) ——类似的还有f(2L):f(long), f(2LU):f(unsigned long)
f('a'); //f(char)
f("a"); //f(char const *) ——注意这里有个const修饰，所以在f中试图改变指针的内容会报编译错。
char *p = "a";
f(p); //f(char *)
char *&rp = p;
f(rp); //f(char *) ——注意引用符号并没有输出来，但引用符号确实可以作为重载的材料

ClassA a;
f(a); //f(class ClassA) ——类似的还有f(union un), f(enum en)

TemClassB<int> b;
f(b); //f(class TemClassB<int>)

string str = "a";
f(str); //f(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)

TemClassB<string> bs;
f(bs); //f(class B<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >)

class LocalClass{};
LocalClass c;
f(c); //error.在模板实例化中使用局部类型

return 0;
}

3. 如何实例化
实质就是编译器决定用什么template_parameter去实例化模板函数。
实际上在第2步中有个匹配的过程，"匹配"即是决定模板参数的过程。
(1) 每个调用函数使用的参数将与函数定义的参数一一对应，但不对应返回值。
显然，参数个数要一样。template_function的template_parameter不能有default值，所以不存在省略某个的参数的做法
template <class T> void f(T t1, T t2) {}
f("a", "b"); //调用参数"a"对应T t1, 调用参数"b"对应T t2

template <class T, class S> S f(T t) { return S(); }
f("a"); //调用参数"a"对应T t
int (*pf)(float) = f; //调用参数类型float对应T，返回值类型int不对应S

(2) 如果定义中，参数的类型为已知类型，即不含template_parameter中的类型。那么调用的参数可以作ordinary_conversion常规转换到要求的类型
如果定义中，参数的类型为parameter type，那么如果调用的参数作下面的转换可以到要求的类型，则也算匹配：
1. lvalue -> rvalue:
parameter type为rvalue，而调用的参数为lvalue
比如：
template <class T> void f(T t) {}
template <class S> void g(S &s) {}
int main()
{
f(0); //这里就不需要lvalue-rvalue的转换，因为0为rvalue, t也为rvalue

int i = 0;
f( i ); //这里就需要lvalue-rvalue的转换，因为i为rvalue, t为rvalue

g(0); //error:int不能转换为int&. 这里企图进行rvalue-lvalue的转换，但是不容许
g(i); //i为rvalue, s为rvalue，不需要任何转换
}
一般，如果函数的参数和返回值不是一个引用类型，那么它返回的就是一个rvalue的转换。
2. qualification conversion:
这里的qualification指const, volatile.
parameter type中含这些qualification，但调用的参数中则没有
比如：
template <class T> void f(T const t) {}
int main()
{
int i = 0;
f( i ); //t为int const类型，而i为int类型。qualification conversion发生
}
3. derived-base
parameter type为基类，而调用的参数为子类

注意：当参数类型为数组类型时，其实质为指针。所以数组——指针不算转换。

这三种转换为exactly conversion.
当然，如果可能，编译器不做任何转换即得出parameter type的值。
经过本匹配，编译器可以得到一个parameter type的值
(3)依次顺序地分析所有调用的参数。
如果分析中发现某个parameter type有两种类型，编译器是不会试着去转换这两者类型的，直接pass掉，即认为调用与本目标不匹配。
template <class T> void f(T t1, T t2) {}
f('1', 2); //error：模板参数T不明确
//分析参数'1'时得出T为char, 分析参数2时得出T为int，两者矛盾

如果分析完后，parameter list中仍然有人没有值，那么匹配不成功。
template <class T, class S> S f(T t) { return S(); }
int i = f(2); //error:未能推导出S的模板参数
//T为int
//虽然调用时要求返回值为int类型，但编译器是靠函数调用的参数列表来分析出模板参数的。此时分析不出来S的类型来。

int (*pf)(int) = f; //error:未能推导出S的模板参数。原因与上面相同

(4)按(1)(2)(3)步骤匹配其它重载的函数，找到"最匹配的函数"。
如果有两个“最匹配的函数”，则报“ambiguous call to overloaded function”编译错，即“两义调用”
比如：
template <class T> void f(T t1, T t2) {} //1
template <class T> void f(T t1, T const t2) {} //error. const不能作为重载的材料
template <class T> void f(T t1, double d) {} //3
template <class T> void f(char c, T t2) {} //4

template <class T> void g(T t1, double d) {} //5

int main()
{
f(1, 3); //1匹配， T 为 int,
f(1, 3.0); //3匹配， T 为 int
f('1', 3); //4匹配， T 为 int
f('1', 3.0); //error： 3和4都为最佳匹配，则为两义调用。

g(1, 3); //5匹配， T 为int。 参数3会转换为类型double

}

例外：
template <class T> void f(T t1, T t2) {}
template <class T, class S> void f(T t, S s) {}
f(3, 4) //调用 f(T t1, T t2) 还是 f(T t, S s)？好像都是最佳匹配？是否有编译错？
//ok. 调用f(T t1, T t2)。
//与两函数定义的次序没有关系。具体原因未知。按理f(T t1, T t2)更匹配是合理的，难道是"最佳最简单匹配"？

不过：
template <class T, class S> S f(T t1, T t2) {} //与上面的区别是返回值为S类型
template <class T, class S> S f(T t, S s) {} //与上面的区别是返回值为S类型
f(3, 4); //ok.调用f(T t, S s)。
//因为f(T t1, T t2)函数推导不出S的值，所以pass掉。此处是与上面的例外作比较。

注意：如果让编译器自己推导template_parameter的值不太直观的话，可以显示调用，即直接指定参数的值：
f<int, int>(3, 4);
f<int, double>(3, 4); //这个调用参数4会转换为double型
f<int, string>(3, 4); //error:4无法转换为std::string类型

如果靠后的参数编译器自己可以推导出来，那么可以省略：
f<int>(3, 4);
f<int>(3, 4.0); //这个与f<int, double>(3, 4.0)等

上面的输出中显示了匹配的函数规格，这个也就是用来作为实例化模板函数的template_parameter

如果第3步也没有找到匹配的函数，则该调用就错了。

一旦在第(2)、(3)步中引起了实例化，那么实例化生成的函数就成为了一个普通的函数，那么它就会碰到些普通函数会遇到的问题：
1.如果在实例化地方的后面又有相同原形的函数定义，则报“重复定义”
比如在两个.cpp中都显式规格化同一个template_function

比如在实例化地方的后面又有一个普通函数的定义或显示规格化template_function的定义有相同原形

在header中声明所有函数，或在调用前声明所有函数，可避免这种错误。

2.实例化后所有template parameter都确定了，所以在函数体中使用这些parameter的地方是否符合语法，编译器会检查
比如:
template <class T>
void f(T t) { cout << T << T.size() << endl; }
函数f假定类型T支持'<<'操作符，并且有size()成员函数，如果实例化后发现没有，则会报编译错。
这种错误正是显式规格化模板函数的最大用处。对于例外的且常见的类型显式定义一个规格可以解决本问题。
3. 同一个文件中，如果再碰到匹配的函数调用，则编译器不会再实例化了。
但在不同的文件中，会各自实例化同一个函数规格，好像它们不去判断其他人是否已实例化同一个函数规格。