c＋＋模板是什么?帮我解释下，谢谢！

参考读物：

《Thinking in C++: vol1 & vol2》 Bruce Eckel - wwwbruceeckelcom

《C++ Template》 David Vandevoorde, Nicolai M Josuttis

推荐读物：

《modern C++ design》Andrei Alexandrescu

1 介绍

模板是一个包含有未指定类型的函数或类，因此模板并不是一个真正的函数或类，而是代表了一组函数或类，当为模板函数或类指定了一种类型时，就生成了此模板的一个实例，这个 *** 作叫做模板实例化（instantiation）。也可以为某一种类型提供不同于模板的定义，这个称为特化定义（specialization）。对于有多个类型参数的模板，还可以只指定一部分类型，这个称为偏特化定义（partial specialization）。

模板不是实体，因此模板的声明和定义通常都放在头文件中。

2 函数模板

21 声明

template<class T>

inline void func(T param)

{

}

22 函数模板不支持默认类型参数，但支持函数的默认参数

template<class T/ = type，不可以 />

void func(T param, int size = sizeof(T))

{

}

23 函数模板显式实例化声明

template void func<int>(int param);

显式实例化后的函数模板不能再有不能转换的类型的调用

显式实例化后的函数模板不能被特化定义

24 特化定义函数模板

template<>

void func<int>(int param) //函数模板只支持全特化

{

}

特化后是一个实体函数，不再是模板，放在头文件中会导致重定义

25 函数模板重载

template<class T>

void func(T param, int i)

{

}

template<>

void func(ClassName param, int i)

{

}

void func(int i)

{

}

这几种func函数的定义，匹配的顺序是非模板函数 -> 特化函数模板 -> 基函数模板。如果不像func<int>(100)这样指定函数模板的参数类型的话，编译器会为函数模板推测出一种类型，如根据100为int类型，编译器会自动调用func<int>，称为隐式特化，而前者则成为显式特化。

为什么函数模板要特化呢？这是因为有时候函数模板并不能处理所有情况，对于个别情况就可以使用特化来替换掉原来模板。

3 类模板

31 声明

template<class T>

class ClassName

{

};

32 类方法类外定义

template<class T>

ReturnType ClassName<T>::Func()

{

};

33 非类型（nontype）模板参数

如template<size_t _Nb> class bitset {}就是使用size_t类型参数设置位的个数。

可以是常量整数类型（包括枚举）或外部链接（external linkage）对象的指针或引用作为模板参数，不能是浮点型和类对象。

char s = "hello"; //s不可以，直接使用"hello"亦不可以，因为两个"hello"可能为不同地址

char s[] = "hello"; //s可以

ClassName obj; //obj可以

ClassName<int> obj; //obj可以

什么是一个外部链接对象呢？

关于这个问题，专门转载了SpitFire同志的一篇文章《内部链接和外部链接》到博客中

总的说来，要作为参数必须满足：1、在编译时和链接时可以求值； 2、这个参数如果是指针，则它所指的变量，如果在两个cpp中定义会出链接错误。

不同的参数值构成不同的类型，bitset<100>和bitset<200>是两个类型

34 默认参数

template<class T = int, int param = 100>

class ClassName

{

};

35 以模板为类型参数的类模板声明

template<class T>

class Array;

template<class T1, template<class / 可以省略类型名 / > class T2>

class ClassName

{

T2<T1> m_o;

}

如果T2是带默认参数的：template<class U, int i = 100> class T2; 则在以它为类型参数的类中必须再次指明默认值，如果两个默认值不同以再次声明的为准。

template<class T, int i = 100>

class Array;

template<class T1, template<class, int = 100> class T2>

class ClassName

{

T2<T1> m_u;

}

使用：

ClassName<int, Array> obj;

36 特化模板类

template<class A, class B>

class ClassName

{

};

361 全特化

template<>

class ClassName<int, double>

{

}; //特化后是一个实体类，不再是模板

362 偏特化

template<class B>

class ClassName<int, B>

{

}; //特化后是一个实体类，仍是模板

template<class A, class B>

class ClassName<A, B>

{

};

363 类成员函数特化

template<class T>

class ClassName

{

public: void f();

};

template<>

inline void class ClassName<int> :: f()

{

} //特化类ClassName<int>的f()，T为int类型时优先调用此定义

37 模板类里的静态变量

template<class T>

class ClassName

{

static T a;

}

定义：

int ClassName<int>::a = 100; / 定义一个与类模板的类型参数对应的静态变量 /

main()

{

ClassName<int> o;

}

38 typename关键词

381 表明紧跟在后面的是类型，而不是其他（如静态变量）

typename vector<T>::iterator it;

382 定义新类型

typedef typename vetor<T>::iterator Iterator_Type;

383 代替模板中的class关键词

template<typename T>

class ClassName

{

};

39 模板类中的成员函数模板

template<class T>

class ClassName

{

public:

template<class T1, class T2> T m_func(T1 a, T2 b);

}

类外定义:

template<class T>

template<class T1, class T2>

T ClassName<T>::m_func(T1 a, T2 b)

{

}

特化

template<>

template<>

int ClassName<int>::m_func(int a, int b) //类必须被一起全特化

{

}

调用：

ClassName<int> o;

otemplate m_func<int, vector<int> >(100, vector<int>()); //调用时实例化

310 继承模板类

template<class T>

class Chlid : public Parent<T>

{

};

3101 特化继承

class ClassName : public vector<int>

{

};

311 explicit关键字

explicit Y(const X& x);

X x; Y y(x); //显式转换

X x; Y y = x; //隐式转换，编译不通过

第一条语句通过使用显式从X类型转换生成了一个Y类型的对象，后一条语句则使用了隐式转换创建。由于使用了explicit要求必须使用显式，所以编译没有通过。

4 总结

模板加强了使用C++编写可复用代码的能力，但是想学好模板需要花费很大的功夫和精力的，而最难的就是将模板和原有C++面向对象的技术，如继承和多态等，相互融会贯通。

这一块是有点痛苦。经过我长时间的总结与分析。得到简单点的：

先说显示具体化：

声明：template<class T>

void test(T t); //这个在显示具体化中为一般的模板函数

template<> void test<int> (int a); //显示具体化函数

定义: template<class T>

void test(T t){ }

template<> void test<int>(int a){ }

调用：直接用函数名称即可

如：test(3); //参数为int，调用具体化

test(33); //参数不为int, 调用一般模板函数

再看一下实例具体化：

声明：template<class T>

void test(T t);

void test(float f);

定义：template<class T>

void test(T t){} //实例具体化函数

void test(float t){} //一般函数，拿来对比

调用：这点区别很大

template void test<int>(int t); //要先说明一下类型才能调用实例具体化

test(3); //参数为int，调用实例具体化

test(33); //参数不为int, 调用一般函数

从上面可以看出，其实显示具体化就是在函数声明的时候就已经确定了具体类型要调用的具体函数，而实例具体化是在函数调用的时候去确定一个类型，使其调用具体化的函数

从这两个可以看出，两个实例化就是为了照顾一些你想特殊处理的类型，让它不按模板进行，说白了就是搞特殊嘛，呵呵，编程也得有特殊待遇。

以上就是我总结出来的，希望对你有帮助。如果你在学习过程中觉得有不对的地方，请指出。呵呵，一起学习，共同提高。

C++ 模板基础谈1 什么是模板模板定义：模板就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码可重用性。我们知道，C++ 是一种“强类型”的语言，也就是说一个变量，编译器必须确切的知道它的类型，而模板就是构建在这个强类型语言基础上的泛型系统。2 模板的语法模板函数template< typename {类型参数名称}, [ int {Name}=][, ] >{函数定义}模板类template< typename , [ int {Name}=] >class 模板的参数可以是类型，或者是一个 int 型的值（或者可以转换为int 型的，比如 bool）。3 模板的使用显式类型参数：对于模板函数，在函数名后添加 < {类型参数表} >。对于模板类，在类后添加 < {类型参数表} >隐式类型参数：对于模板函数，如果类型参数可以推导，那么可以省略类型参数表举个例子:template< typename T >T max( T a, T b ){ return a < b b : a;}这个 max 函数就是一个模板函数，它可以传入一个 “类型”的参数，以便实现任意类型求最大值的效果。假设我们这样使用它：int x=5, y=10;int z=max<int>( x, y );这时候发生了什么呢？我们传入的“类型参数”是int，因此编译器在编译这段代码时会使用 int 来构造一个新函数：int max( int a, int b ){ return a < b b : a;}后面的事就和编译普通的函数一样了，C++编译器继续使用强类型系统编译这个函数，由强类型系统来检查这个函数是否正确。这个过程叫做模板的“特化”，它发生在编译期，当编译器发现模板函数、模板类被使用（注意，不是定义）的时候进行的。这个系统实际上比较像宏，但是比宏更为智能。很明显，编译器必须知道模板如何特化这个函数，因此模板函数的实现，必须在“使用点”之前，因此模板库只能通过头文件库的形式来提供。4 模板的类型推导对于函数，编译器是知道传入参数的类型的，比如上面的max，max< >( x, y )，由于第一个参数 x 是 int 类型的，那么 这里需要填写什么呢？我们可以很明显的推断出应该是 "int"，否则，后面的强类型系统将无法编译这个函数。编译器同样知道 x 的类型，因此它也能推导出“类型参数”，这时候我们调用时就可省略模板参数了。这个推导是按顺序来的，因此如果上面的 y 是其他类型， 仍然会被推导为 int，如果y无法隐性转换为int，强类型编译时就会报错。5 类型推导的隐式类型转换在决定模板参数类型前，编译器执行下列隐式类型转换： 左值变换 修饰字转换 派生类到基类的转换 见《C++ Primer》（[注2]，P500）对此主题的完备讨论。简而言之，编译器削弱了某些类型属性，例如我们例子中的引用类型的左值属性。举例来说，编译器用值类型实例化函数模板，而不是用相应的引用类型。同样地，它用指针类型实例化函数模板，而不是相应的数组类型。它去除const修饰，绝不会用const类型实例化函数模板，总是用相应的非 const类型，不过对于指针来说，指针和 const 指针是不同的类型。底线是：自动模板参数推导包含类型转换，并且在编译器自动决定模板参数时某些类型属性将丢失。这些类型属性可以在使用显式函数模板参数申明时得以保留。6 模板的偏特化如果我们打算给模板函数（类）的某个特定类型写一个函数，就需要用到模板的偏特化，比如我们打算用 long 类型调用 max 的时候，返回小的值（原谅我举了不恰当的例子）：template<> // 这代表了下面是一个模板函数long max<long>( long a, long b ) // 对于 vc 来说，这里的 <long> 是可以省略的{ return a > b b : a;}实际上，所谓偏特化，就是代替编译器完成了对指定类型的特化工作，现代的模板库中，大量的使用了这个技巧。7 仿函数仿函数这个词经常会出现在模板库里（比如 STL），那么什么是仿函数呢？顾名思义：仿函数就是能像函数一样工作的东西，请原谅我用东西这样一个代词，下面我会慢慢解释。void dosome( int i )这个 dosome 是一个函数，我们可以这样来使用它： dosome(5);那么，有什么东西可以像这样工作么？答案1：重载了 () *** 作符的对象，比如： struct DoSome { void operator()( int i ); } DoSome dosome;这里类(对 C++ 来说，struct 和类是相同的) 重载了 () *** 作符，因此它的实例 dosome 可以这样用 dosome(5); 和上面的函数调用一模一样，不是么？所以 dosome 就是一个仿函数了。实际上还有答案2： 函数指针指向的对象。 typedef void( DoSomePtr )( int ); typedef void( DoSome )( int ); DoSomePtr ptr=&func; DoSome& dosome=ptr; dosome(5); // 这里又和函数调用一模一样了。当然，答案3 成员函数指针指向的成员函数就是意料之中的答案了。8 仿函数的用处不管是对象还是函数指针等等，它们都是可以被作为参数传递，或者被作为变量保存的。因此我们就可以把一个仿函数传递给一个函数，由这个函数根据需要来调用这个仿函数（有点类似回调）。STL 模板库中，大量使用了这种技巧，来实现库的“灵活”。比如：for_each, 它的源代码大致如下：template< typename Iterator, typename Functor >void for_each( Iterator begin, Iterator end, Fucntor func ){ for( ; begin!=end; begin++ ) func( begin );}这个 for 循环遍历了容器中的每一个元素，对每个元素调用了仿函数 func，这样就实现了 对“每个元素做同样的事”这样一种编程的思想。特别的，如果仿函数是一个对象，这个对象是可以有成员变量的，这就让 仿函数有了“状态”，从而实现了更高的灵活性。