C++模板实例化

实例化：一个通过使用具体值替换模板参数，从模板产生的普通类，函数或者成员函数的过程。

特化：就是上述过程最终获得实体。

延迟实例化：
当隐式实例化类模板时，同时也实例化了该模板的每个成员声明，但并没有实例化相应的定义，然而，存在例外：
1.如果类模板包含了一个匿名的union，那么该union定义的成员同时也被实例化了
2.作为实例化类模板的结果，虚函数的定义可能被实例化，但也可能没有，这依赖于具体实现

C++的实例化模型：

两阶段查找：
第1阶段：发生在模板的解析阶段
非依赖型名称：普通查找＋ADL
非受限的依赖型名称：普通查找，但它的查找是不完整的，在实例化的时候，还会再次进行查找。

 

第2阶段：发生在模板的实例化阶段，此时发生的地点称为一个实例化点POI
依赖受限名称：普通查找＋ADL
非受限的依赖型名称：ADL （查询完后，和第1阶段的查找结果合并成为候选函数集合）

实例化地点POI:
当某些代码构造引用了模板特化，而且为了生成这个完整的特化，需要实例化相应模板的定义时，就会在源代码中产生一个实例化点（POI）。POI是位于源代码中的一个点，在该点会插入替换后的模板实例。

[cpp] view plaincopy

1. class MyInt  
2. {  
3. public:  
4.     MyInt(int i);  
5. };  
6.   
7. MyInt operator - (const MyInt& );  
8. bool operator > (const MyInt&,const MyInt&);  
9.   
10. typedef MyInt Int;  
11.   
12. template <typename T>  
13. void f(T i)  
14. {  
15.     if(i > 0)  
16.         g(-i);  
17. }  
18.   
19. //(1)  
20. void g(Int)  
21. {  
22.     //(2)  
23.     f<Int>(32);  //调用点  
24.     //(3)  
25. }  
26. //(4)  

当C++编译器看到f<Int>(32)时，它知道要用MyInt来替换T来实例化模板，即生成了一个POI。（2）和（3）处，C++并不允许把::f<Int>(Int)的定义在这里插入。（1）和（4）的区别在于：在（1）处g(Int)是不可见的，所以在（4）处。

C++规定：对于指向非类型特化的引用，它的POI定义在“包含这个引用的定义或声明后的最近名字空间域”。

 

对于类的特化有点不同，例如：

[c-sharp] view plaincopy

1. template <typename T>  
2. class S  
3. {  
4. public:  
5.     T m;  
6. };  
7.   
8. //(5)  
9. unsigned long h()  
10. {  
11.     //(6)  
12.     return ((unsigned long) sizeof(S<int>));  
13.     //(7)  
14. }  
15. //(8)  

当C++编译器看到S<int>时，它知道要用int来替换T来实例化模板，即生成了一个POI。（6）和（7）处，C++并不允许把的定义在这里插入。如果在（8）处，sizeof(S<int>)表达式是无效的，因为要编译到（8）只有才能知道S<int>的大小，而sizeof(S<int>)在（8）之前。C++规定：对于指向产生自模板的类实例的引用，它的POI定义在“包含这个实例引用的定义或声明之前的最近名字空间域”。

 

在实例化模板的时候，可能还需要进行某些附带的实例化。

[cpp] view plaincopy

1. template <typename T>  
2. class S {  
3. public:  
4.     typename int I;  
5. };  
6. //(1)  
7. template <typename T>  
8. void f() {  
9.     S<char>::I var1 = 41;  
10.     typename S<T>::I var2 = 42;  
11. }  
12. int main() {  
13.     f<double>();  
14. }  
15. //(2):(2a)(2b)  

对于非类型实体，这种二次POI的位置和主POI的位置相同。
对于类型实体，二次POI的位置位于主POI位置的紧前处。
对于上例中，(1)处是S<char>的POI，(2a)是S<double>的POI，(2b)是f<double>的POI。

显式实例化：
从语法上讲，显式实例化指示符由关键字template和后面的特化声明组成，所声明的特化就是即将由实例化获得的特化。
在同一个程序中，每个特定的模板特化最多只能存在一处显式实例化，而且，如果某个模板特化已经被显式实例化了，就不能对它进行显式特殊化。
提高创建效率的一种方法是：在某一个位置手工实例化特定的模板特化，并且禁止在所有其他的翻译单元中进行模板的实例化。
在显式实例化指示符的前面，添加一个关键字extern，并且指出，只有不具备这个关键字的情况下，才会引发实例化过程。
例：

[cpp] view plaincopy

1. //翻译单元1  
2. template <typename T>  
3. void f() { }  
4. extern template void f<int> ();   //声明但没有定义  
5. void g() {  
6.     f<int>();  
7. }  
8. //翻译单元2  
9. template <typename T>   
10. void f() { }  
11. template void f<int>();       //手工实例化，这是实例化  
12. void g();  
13. int main() {  
14.     g();  
15. }