C++知识点总结7 模板II

非类型模板参数

     模板参数分为类型形参与非类型形参。

     类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

     非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。     

    namespace xxx

     {

         // 定义一个模板类型的静态数组

         template<class T,size_t N = 10>

         class array

         {

         public:

             T& operator[](size_t index)

             {

                 return _array[index];

              }

             const T& operator[](size_t index) const

             {

                 return _array[index];

              }

             size_t size() const

             {

                 return _size;

             }

             bool empty() const

             {

                 return 0 == _size;

              }

         private:

             T _array[N]; size_t _size;

         }；

     } 

     注意：

     1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。

     2. 非类型的模板参数必须在编译期就能确认结果。

模板的特化

     概念

     通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，比如：    

     template<class T>
     bool IsEqual(T& left, T& right)
     {
        return left == right;
     }
     void Test()
     {
        char* p1 = "hello";
        char* p2 = "world";
        if(IsEqual(p1, p2))
            cout<<p1<<endl;
        else
            cout<<p2<<endl;
     }

     此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

     函数模板特化

     函数模板的特化步骤：

     1. 必须要先有一个基础的函数模板

     2. 关键字template后面接一对空的尖括号<>

     3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型

     4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

      注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。     

     类模板特化

     全特化：即是将模板参数列表中所有的参数都确定化    

     template<class T1,class T2> 

     class Data

     {

     public:

         Data()

         {

             cout<<"Data<T1,T2>" <<endl;

          }

     private:

          T1 _d1;

          T2 _d2;

    };

     template<>
     class Data<int, char>
     {
     public:
        Data()

        {

             cout<<"Data<int, char>" <<endl;

         }
     private:
        T1 _d1;
        T2 _d2;
     };

     void TestVector()

     {

         Data d1;

         Data d2;

     } 

     偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类：   

     template<class T1, class T2>
     class Data
     {
     public:
        Data()

        {

             cout<<"Data<T1, T2>" <<endl;

         }
     private:
        T1 _d1;
        T2 _d2;
     };

     偏特化有以下两种表现方式：

     部分特化: 将模板参数类表中的一部分参数特化。    

     // 将第二个参数特化为int
     template <class T1>
     class Data<T1, int>
     {
     public:
        Data()

        {

             cout<<"Data<T1, int>" <<endl;

         }
     private:
        T1 _d1;
        int _d2;
     };

     参数更进一步的限制: 偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。   

     //两个参数偏特化为指针类型
     template <typename T1, typename T2>
     class Data <T1*, T2*>
     {
     public:
        Data()

        {

             cout<<"Data<T1*, T2*>" <<endl;

         }
     private:
        T1 _d1;
        T2 _d2;
     };

     //两个参数偏特化为引用类型

     template <typename T1, typename T2>
     class Data <T1&, T2&>
     {
     public:
        Data(const T1& d1, const T2& d2) : _d1(d1) , _d2(d2)

        {

             cout<<"Data<T1&, T2&>" <<endl;

         }
     private:
        T1& _d1;
        T2& _d2;
     };

     void test2 ()

     {

         Data<double , int> d1; // 调用特化的int版本

         Data<int,double> d2; // 调用基础的模板

         Data<int*,int*> d3; // 调用特化的指针版本

         Data<int&,int&> d4(1, 2); // 调用特化的指针版本

     } 

模板分离编译 

     什么是分离编译?

     一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

    一般将函数或者类的声明放到.h文件中，将函数或者类的定义放到.cpp中。（方便查看和维护）

    文档：http://blog.csdn.net/pongba/article/details/19130

    同样是分离编译，普通函数、类可以，而函数模板/类不行，为什么？

    分析：因为模板只有在使用时才会实例化，没有生成具体代码，所以链接时报错。

    解决方法：

     1. 将声明和定义放到一个文件xxx.cpp 里面或者xxx.h其实也是可以的。推荐使用这种。

     2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

模板总结

     优点：

     1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生

     2. 增强了代码的灵活性

     缺陷：

     1. 模板会导致代码膨胀问题，也会导致编译时间变长

     2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误