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;
    }