类模板

（1）要注意什么时候使用类名，什么时候使用类的类型

例如：

1. #include <vector>
2. #include<stdexcept>
5. template<typename T>
6. class Stack{
7. private:
8.     std::vector<T> elems;
10. public:
11.     void push(T  const&);
12.     void  pop();
13.     T top() const;
14.     bool empty() const{
15.         return elems.empty();
16.     }
17. };
20. template<typename T>
21. void Stack<T>::push(T const& elem)
22. {
23.     elems.push_back(elem);
24. }
26. template<typename T>
27. void Stack<T>::pop(){
28.     if(elems.empty()){
29.         throw std::out_of_range("Stack<T>::pop():  empty elems");
30.     }
31.     elems.pop_back();
32. }
34. template<typename T>
35. T Stack<T>::top() const{
36.     if(elems.empty()){
37.         throw std::out_of_range("Stack<T>::pop():  empty elems");
38.     }
39.     return elems.back();
40. }

当实现自己的构造函数、析构函数时，应该使用类名，而在实现自己的拷贝构造函数和赋值函数时应使用类型：

如:

1. template <typenaem T>
2. class Stack{
3.   private:
4.       ....
5.       Stack(Stack<T> const&);
6.       Stack<T>&  operator=(Stack<T> const&);
7.       ....
9. };

拷贝构造函数中的参数是类型，所以使用了Stack<T>表示。

 

（2）成员函数的实现：

如

1. template<typename T>
2. void Stack<T>::push(T const& elem)
3. {
4.     elems.push_back(elem);
5. }

为了定义一个类模板的成员函数，必须指定该成员函数是一个模板函数，而且还要使用这个类模板的完整类型限定符。如

Stack<T>.

 

（3）类模板的使用

   注意，只有那些被调用的成员函数，才能产生函数的实例化代码。对与类模板，成员函数只有在被使用的时候才会被实例化。这样可以节省空间和时间；另一个好处就是：对于那些“未能提供所有成员函数中所有操作的”类型，你也可以使用该类型来实例化类模板，只要对那些“未能提供某些操作的”成员函数，模板内部不使用即可。

 

 

 

（4）类模板的特化

        通过特化类模板，我们可以优化基于某种特定类型的实现，或者克服某种特定类型在实例化类模板时所出现的不足。另外，如果要特化一个类模板，你还要特化该类模板的所有成员函数。虽然也可以只特化某个成员函数，但是这个做法并没有特化整个类，也就没有特化整个类模板。

      为了特化一个类模板，你必须在起始处声明一个template<>，接下来声明用来特化类模板的类型。这个类型被用作模板实参，且必须在类名的后面直接指定：

1. template<>
2. class Stack<std::string>{
3. .......
4. }

 

   进行类模板的特化时，每个成员函数都必须重新定义为普通函数，原来模板函数中的每个T也应被进行特化的类型取代：

1. void Stack<std::string>::push(std::string const& elem)
2. {
3.    elems.push_back(elem);
4. }

（5）局部特化

        类模板可以被局部特化。我们可以在特定的环境下指定类模板的特定实现，并且要求某些模板参数仍然必须由用户来定义。例如类模板：

1. template<typename T1,typename T2>
2. class MyClass{
3. .....
4. };

可以有以下几种局部特化：

 

1. template<typename T>
2. class MyClass<T,T>{
3. .....
4. };
6. template<typename T>
7. class MyClass<T,int>{//第二个模板参数的类型是int
8. .....
9. };

但是要注意其中有可能产生的二义性。

 

（6）缺省模板实参

 对于类模板，你还可以为模板参数定义缺省值；这些值就被称为缺省模板参数；而且，它们还可以引用之前的模板参数。例如，在类Stack<>中，你可以把用于管理元素的容器定义为第2个模板参数，并且使用std::vector<>作为它的缺省值：

1. #include<vector>
2. #include<stdexcept>
4. template <typename T, typename Cont=std::vector<T>  >
5. class Stack{
6. private:
7.     Cont elems;
9. public:
10.     void push(T  const&);
11.     void pop();
12.     T top() const;
13.     bool empty() const{
14.         return elems.empty();
15.     }
16. };
18. template <typename T,typename Cont>
19. void  Stack<T ,Cont>::push(T const& elem)
20. {
21.     elems.push_back(elem);
22. }
24. template<typename T,typename Cont>
25. void Stack<T,Cont>::pop()
26. {
27.     if(elems.empty()){
28.         throw std::out_of_range("Stack<>::pop(): empty stack");
29.     }
30.     elems.pop_back();
31. };
33. template<typename T,typename Cont>
34. T Stack<T,Cont>::top() const{
35.     if(elems.empty()){
36.         throw std::out_of_range("Stack<>::top():empty stack");
37.     }
38.     return elems.back();
39. }
44. #include<iostream>
45. #include<deque>
46. #include <cstdlib>
47. #include "stack3.h"
50. int main()
51. {
52.     try
53.     {
54.         Stack<int>  intStack;
55.         Stack<double,std::deque<double>  >dblStack;
57.         intStack.push(7);
58.         std::cout<<intStack.top()<<std::endl;
59.         intStack.pop();
61.         dblStack.push(42.42);
62.         std::cout<<dblStack.top()<<std::endl;
63.         dblStack.pop();
64.         dblStack.pop();
66.     }
67.     catch (std::exception const& ex)
68.     {
69.         std::cerr <<"Exception:"<<ex.what()<<std::endl;
70.         return EXIT_FAILURE;
71.     }
72. }