Step By Step(C++模板类)

    和函数一样，C++中的class也可以类型参数化，其中容器类是极具这一特征的。对于模板类的基本定义和使用，可以参考STL，这里就不做过多的赘述了。下面将主要介绍一下与其相关的高级实用特征。

一、模板的特化：

    这里可以先将类模板特化与面向对象中的多态进行一个简单的比较，这样可以便于我们对它的理解，也同样有助于指导我们在实际的开发中应用这一C++技巧。众所周知，对于多态而言，提供的是统一的接口和不同的实现类实例，其最终的行为将取决于实现类中的实现，相信每一个有面向对象基础的开发者对于这一概念并不陌生。而模板特化则要求必须提供一个标准的模板类(等同于多态中的接口)，与此同时再为不同的类型提供不同的特化版本。在模板特化类中，我们首先需要保证类名是相同的，只是模板参数不再使用抽象的类型，而是直接使用具体的类型来实例化该模板类。在调用时，编译器会根据调用时的类型参数自动选择最为合适的模板类，即如果有特化模板类中的类型参数和当前调用类型相匹配的话，则首选该特化模板类，否则选择最初的标准模板类。见如下用例(请注意代码中的说明性注释)：

    #include <stdio.h>
    #include <string.h>
    
    //1. 这里我们先声明了一个通用类型的模板类。这里要有类型参数必须包含hashCode()方法。
    //否则，该类型在编译期实例化时将会导致编译失败。
    template <typename T>
    class CalcHashClass { //该类为标准模板类(等同于多态中的接口)
    public:
        CalcHashClass(T const& v) : _value(v) {
        }
        int hashCode() {
            printf("This is 'template <typename T> class CalcHashClass'.\n");
            return _value.hashCode() + 10000;
        }
    private:
        T _value;
    };
    
    //2. int类型实例化特化模板类。
    template <>
    class CalcHashClass<int> {
    public:
        CalcHashClass(int const& v) : _value(v) {
        }
        int hashCode() {
            printf("This is 'template <> class CalcHashClass<int>'.\n");
            return _value * 101;
        }
    private:
        int _value;
    };
    
    //3. const char*类型实例化的特化模板类
    template<>
    class CalcHashClass<const char*> {
    public:
        CalcHashClass(const char* v) {
            _v = new char[strlen(v) + 1];
            strcpy(_v,v);
        }
        ~CalcHashClass() {
            delete [] _v;
        }
        int hashCode() {
            printf("This is 'template <> class CalcHashClass<const char*>'.\n");
            int len = strlen(_v);
            int code = 0;
            for (int i = 0; i < len; ++i)
                code += (int)_v[i];
            return code;
        }
    
    private:
        char* _v;
    };
    
    //4. 辅助函数，用于帮助调用者通过函数的参数类型自动进行类型推演，以让编译器决定该
    //实例化哪个模板类。这样就可以使调用者不必在显示指定模板类的类型了。这一点和多态有
    //点儿类似。
    template<typename T>
    inline int CalcHashCode(T v) {
        CalcHashClass<T> t(v);
        return t.hashCode();
    }
    
    //5. 给出一个范例类，该类必须包含hashCode方法，否则将造成编译错误。
    class TestClass {
    public:
        TestClass(const char* v) {
            _v = new char[strlen(v) + 1];
            strcpy(_v,v);
        }
        ~TestClass() {
            delete [] _v;
        }
    public:
        int hashCode() {
            int len = strlen(_v);
            int code = 0;
            for (int i = 0; i < len; ++i)
                code += (int)_v[i];
            return code;
        }
    private:
        char* _v;
    };
    
    int main() {
        TestClass tc("Hello");
        CalcHashClass<TestClass> t1(tc);
        printf("The hashcode is %d.\n",t1.hashCode());
        //这里由于为模板类TestClass提供了基于int类型的模板特化类，因此编译器会自动选择
        //更为特化的模板类作为t2的目标类。
        CalcHashClass<int> t2(10);
        printf("The hashcode is %d.\n",t2.hashCode());
    
        //在上面的示例中，我们通过显示的给出类型信息以实例化不同的模板类，这是因为模板类
        //的类型信息是无法像模板函数那样可以通过函数参数进行推演的，为了弥补这一缺失，我们可以
        //通过一个额外的模板函数来帮助我们完成这一功能。事实上，这一技巧在Thinking in Java中
        //也同样给出了。
        printf("Ths hashcode is %d.\n",CalcHashCode(10));
        printf("Ths hashcode is %d.\n",CalcHashCode("Hello"));
        return 0;
    }
    //This is 'template <typename T> class CalcHashClass'.
    //The hashcode is 10500.
    //This is 'template <> class CalcHashClass<int>'.
    //The hashcode is 1010.
    //This is 'template <> class CalcHashClass<int>'.
    //Ths hashcode is 1010.
    //This is 'template <> class CalcHashClass<const char*>'.
    //Ths hashcode is 500.

    通过上面的示例可以看出，模板特化是依赖于编译器在编译期动态决定该使用哪个特化类，或是标准模板类的。相比于多态的后期动态绑定，该方式的运行效率更高，同时灵活性也没有被更多的牺牲。
    下面将给出一个结合模板特化和多态的示例(请注意代码中的说明性注释)：

    #include <stdio.h>
    #include <string.h>
    
    //1. 定义一个接口
    class BaseInterface {
    public:
        virtual ~BaseInterface() {}
        virtual void doPrint() = 0;
    };
    
    //2. 标准模板类继承该接口，同时给出自己的doPrint()实现。
    template<typename T>
    class DeriveClass : public BaseInterface {
    public:    
        void doPrint() {
            printf("This is 'template<typename T> class DeriveClass'.\n");
        }
    };
    
    //3. 基于int类型特化后的DeriveClass模板类，同样继承了该接口，也给出了自己的DoPrint()实现。
    template<>
    class DeriveClass<int> : public BaseInterface {
    public:    
        void doPrint() {
            printf("This is 'template<> class DeriveClass<int>'.\n");
        }
    };
    
    //4. 对象创建辅助函数，该函数可以通过参数类型的不同，实例化不同的接口子类。
    template<typename T>
    inline BaseInterface* DoTest(T t) {
        return new DeriveClass<T>;
    }
    
    int main() {
        BaseInterface* b1 = DoTest(4.5f);
        b1->doPrint();
        BaseInterface* b2 = DoTest(5);
        b2->doPrint();
        delete b1;
        delete b2;
        return 0;
    }
    //This is 'template<typename T> class DeriveClass'.
    //This is 'template<> class DeriveClass<int>'.    

   
二、模板部分特化：

    有的书中将其翻译成模板偏特化，或者是模板的局部特化，但含义都是相同的。为了便于理解，我们可以将上面的模板特化称为模板全部特化，即模板类的类型参数全部被特化了。顾名思义，模板部分特化只是将其中一部分类型参数进行了特化声明，因此也可以将模板特化视为模板部分特化的一种特殊形式。由于应用场景基本相同，因此下面的代码将仅仅给出最基本的示例和注释说明，以帮助大家熟悉他的语法即可：

    //1. 标准模板类。
    template<typename T1, typename T2>
    class MyClass {
        ... ...
    };
    //2. 两个模板参数具有相同类型的部分特化类。
    template<typename T>
    class MyClass<T,T> {
        ... ...
    }
    //3. 第二个类型参数是int
    template<typename T>
    class MyClass<T,int> {
        ... ...
    }
    //4. 两个模板参数都是指针。
    template<typename T1,typename T2>
    class MyClass<T1*,T2*> {
        ... ...
    }
    //5. 两个模板参数都是相同类型的指针。
    template<typename T>
    class MyClass<T*,T*> {
        ... ...
    }
    //6. 调用示例代码。
    int main() {
        MyClass<int,float> c1;         //调用MyClass<T1,T2>
        MyClass<float,float> c2;    //调用MyClass<T,T>
        MyClass<float,int> c3;      //调用MyClass<T,int>
        MyClass<int*,float*> c4;    //调用MyClass<T1*,T2*> 
        MyClass<int*,int*> c5;      //调用MyClass<T*,T*>
        return 0;
    }

   
三、缺省模板实参：

    和函数的缺省参数一样，C++的模板也同样支持缺省类型参数。

    //1. 第二个类型参数的缺省值是vector<T>
    template<typename T, typename T2 = std::vector<T> >
    class MyClass {
        ... ... 
    }
    int main() {
        MyClass<int> c1;            //第二个类型参数是vector<int> 
        MyClass<int,list<int> > c2; //第二个类型参数是list<int> 
        return 0;
    }

    这种使用缺省模板参数的代码，在STL中比比皆是。
    
四、非类型模板参数：

    模板的类型参数不仅仅可以是类型，也可以是常量，但是常量本身的类型是有限制的，不是所有类型的常量都可以，目前只是整型常量和外部链接对象的指针可以，而浮点型等其他原始类型，或自定义类型均不可。

    template<typename T, int MAXSIZE>
    class MyContainer {
    public:
        int capacity() const { return MAXSIZE; }
        ... ...
    private:
        T elements[MAXSIZE];
    };
     
    int main() {
        MyContainer<int,50> c1;
        return 0;
    }
    和普通类型模板一样，非类型模板参数也可以有缺省值，如：
    template<typename T, int MAXSIZE = 10>
    class MyContainer {
    public:
        int capacity() const { return MAXSIZE; }
        ... ...
    private:
        T elements[MAXSIZE];
    };

   
    最后需要说明的是，不管是普通模板类还是非类型模板类，只要其类型不同，或是常量值不同，就不能将其视为相同类型的对象，这一点同样适用于模板函数。