Step By Step(C++模板基本技巧)

一、typename的另一种使用方式：

    在此之前，我们了解到的有关该关键字的用途更多是针对模板参数的定义。而这里介绍的使用方式则有些不同，主要区别是typename的这种使用方式用于定义或提示编译器，其后修饰的标识符为模板参数中的类型标识符，而不是普通的静态类成员。见以下代码示例和关键性注释。

    #include <stdio.h>

    template<typename T>
    class MyTestClass {
    public:
        //这里的typename是用于通知编译器，其后的MyType是模板T定义的内部类型，从这个代码示例
        //中可以看出，不管是在函数参数、返回值还是定义成员变量定义，都要遵守这一语法规则。
        MyTestClass(typename T::MyType p) : _p(p) {
        }
        typename T::MyType GetData() const {
            return _p; 
        }
    public:
        typename T::MyType _p;
    };
    //在该类中，由于后面的调用需要将其用作MyTestClass的模参，因此他必须typedef名字为MyType的
    //内部类型，否则将会导致编译失败。
    class TemplateParamClass {
    public:
        typedef const char* MyType;
    };
    
    int main() {
        MyTestClass<TemplateParamClass> t("Hello");
        printf("The data is %s.\n",t.GetData());
        return 0;
    }

二、基于不同类型模参的模板类之间的赋值：

    前面的博客已经提到过，编译器会将不同类型实例化后的模板类视为不同的类型，因此在这种不同的类型之间进行赋值，如果没有提供必要的方法是无法正常编译的，如：

    template <typename T>
    class TestClass {
        ... ...
    }
    int main() {
        TestClass<int> intClass;
        TestClass<double> doubleClass = intClass;
    }

    上例中的代码是无法成功编译的，因为在C++编译器看来，TestClass<int>和TestClass<double>就是两个完全不同的类型，这样也就无法利用C++编译器自动生成的缺省赋值函数完全这一赋值功能。如何修改才可以达到这一效果呢，见如下代码示例和关键性注释。

    #include <stdio.h>
    
    template <typename T>
    class TestClass {
    public:
        TestClass(T v) : _value(v) {
        }
        template<typename T2>
        TestClass<T>& operator= (const TestClass<T2>& other) {
            //这是编写重载赋值操作符的基本技巧，既不能进行自身对自身的赋值。
            if ((void*)this == (void*)&other)
                return *this;
            //需要说明的是，由于other和this是通过不同类型实例化的模板类，因此这里不能
            //像普通类那样直接调用other._value。编译器将他们视为不同的类型，所以也就不
            //能直接访问其私有变量了。
            _value = other.getValue();
            return *this;
        }
        T getValue() const {
            return _value;
        }
    private:
        T _value;
    };
    
    int main() {
        TestClass<int> intClass(5);
        TestClass<double> doubleClass(6.4);
        printf("The value before assignment is %f.\n",doubleClass.getValue());
        //此时的T为double，T2为int。
        doubleClass = intClass;
        printf("The value after assignment is %f.\n",doubleClass.getValue());
        return 0;
    }
    //The value before assignment is 6.400000.
    //The value after assignment is 5.000000.  

三、模板的模板参数：

    所谓的模板的模板参数，是指模板的参数是另外一个模板类。如：
    template<typename T>
    class TestClass {
        ... ...
    }
    对于上面的模板类，其模参类型并没有任何限制，即可以为任意类型，如普通原始类型、类类型，模板类等。而对于要求模参必须要模板类类型的模板类而言，其模参必须是模板类，否则将无法通过编译。如：
    template <template <typename T> class TemplateClass >
    class TemplateTemplateClass {
        ... ...
    }
    对于上面的模板类，其模参必须是符合template<typename T> class签名的模板类，该类只有一个普通模参。见如下示例代码和关键性注释。

    #include <stdio.h>
    //该模板类的第二个模板必须是另外一个模板类。
    template<typename T, template <typename T> class TemplateClass>
    class TemplateTemplateClass {
    public:
        TemplateTemplateClass(const TemplateClass<T>& tempClass)
            : _internalClass(tempClass) {
        }
        void doTest() {
            _internalClass.doTest();
        }
    private:
        TemplateClass<T> _internalClass;
    };
    
    template <typename T>
    class MyTemplateClass {
    public:
        void doTest() {
            printf("This is MyTemplateClass::doTest().\n");
        }
    };
    
    int main() {
        MyTemplateClass<int> tempClass;
        TemplateTemplateClass<int,MyTemplateClass> tempTempClass(tempClass);
        tempTempClass.doTest();
        return 0;
    }
    //This is MyTemplateClass::doTest().

四、零初始化：

    对于成员变量而言，我们通常的做法是在类构造函数的初始化列表中完成这些成员变量的初始化工作，以免在使用这些变量时造成一些不必要的Bug。对于模板参数类型的成员变量我们应该如何处理呢？见如下示例代码和关键性注释：

    #include <stdio.h>

    template <typename T>
    class TestClass {
    public:
        //1. 第一步是为模板类提供一个缺省构造函数，在该函数的初始化列表中显示的完成
        //模参类型成员的变量的初始化。
        //2. 在这个例子中，要求模板类型或者为原始类型，如int、double等。倘若是类类型
        //则该类必须提供缺省构造函数，否则将导致编译失败。
        //3. 对于原始类型，如int，在执行完_value()之后，其值将被初始化为0。
        TestClass() : _value() {
        }
    private:
        T _value;
    };
    int main() {
        TestClass<int> t;
        return 0;
    }

五、使用字符串作为模板函数的实参：

    见如下代码：

    template<typename T>
    inline T const& max(T const& a, T const& b) {
        return a < b ? b : a;
    }

    如果上述函数的模参类型为char*，那么函数在执行时将会直接使用指针的地址值直接进行比较，而不是按照一个常规方式，按照指针所指向的字符串数据进行lexical方式的比较。
    对于上述函数还存在一个比较隐式的问题，即如果函数的参数不是char*而是字符数组的话，由于max的参数为T const&引用类型，因此在模板函数实例化时将会造成很多限制，见如下代码示例：

    #include <stdio.h>
    #include <typeinfo>
    
    template <typename T>
    void ref(T const& x) {
        printf("x in ref(T const&): %s.\n",typeid(x).name());
    }
    
    template <typename T>
    void nonref(T x) {
        printf("x in nonref(T): %s.\n",typeid(x).name());
    }
    
    int main() {
        ref("Hello");
        nonref("Hello");
        return 0;
    }
    //x in ref(T const&): char const [6].
    //x in nonref(T): char const *.

    从上述输出结果可以看出，使用引用作为函数参数时，编译器会将模板实参推演为字符串数组，而非引用方式则不会。由于可以得出：

    int main() {
        //可以编译通过，因为他们都是char const [6]
        max("apple","peach"); 
        //不可以编译通过，因为这两个函数参数的类型分别为char const[6]和char const [5]
        //对于这种情况，我们可以考虑重载一个max函数，其函数参数为T，而不是T const&
        max("apple","pear"); 
        return 0;
    }