type traits 之"本质论"

侯捷老师在《STL 源码剖析》说：traits编程方法是一把开启STL源代码大门的钥匙，其重要性也就不必再说了。既然traits编程方法如此重要，那么掌握并领悟其精髓是相当必要了。

    trait的意思是什么？英文意思是attribute，feature等等，中文意思可以解释为特点, 特性。那么type trait就是类型的特性。那什么是类型？类型的特性又有哪些呢？类型也即是用户自定义的类型或是语言提供的一些基本类型。每个类型都具有相关的特性，这些特性可能包括：是否有相应的构造方法和析构方法、这一类型引申出来相应的指针类型和引用类型(比如iterator_traits中的成员)等等。其实一个类型所具有的特性是多得数也数不清的，只能从实践（编程）的需要去看这个类型具有什么样的特性。如STL中的destroy需根据类型是否具备有关痛痒的析构方法来决定具体操作。是否具备有关痛痒的析构方法就是类型的一个特性，在编程实践中的特性。自定义的类型可能就具备有关痛痒的析构方法，而语言提供的一些基本类型就没有。

    traits技巧对类型做了什么？有什么作用？类型和类型的特性本是耦合在一起，通过traits技巧就可以将两者解耦。从某种意思上说traits方法也是对类型的特性做了泛化的工作，通过traits提供的类型特性是泛化的类型特性。从算法使用traits角度看，使用某一泛型类型的算法不必关注具体的类型特性（关注的是泛化的类型特性，即通过traits提供的类型特性）就可以做出正确的算法过程操作；从可扩展角度看，增加或修改新的类型不影响其它的代码，但如果是在type_traits类中增加或修改类型特性对其它代码有极大的影响；从效率方法看，使用type_traits的算法多态性选择是在编译时决定的，比起在运行时决定效率更好。

    在实际代码中所有的具体的类型特性没有基类，但概念上是存在的。如果我们再把通过参数多态性的算法也看成有基类情况的假想，就有下图所示的关系：

 

从图中可看出算法destroy不必关心具体的类型特性traits，client不用关心具体的destroy。destroy概念上存在的基类是通过参数多态实现的，traits概念上存在的基类是通过type_traits编程方法实现的。

    另外得注意的是STL中的iterator相关type_traits的使用跟这里所说的有点不同，如果把类型特性从类中剥离出来看待，那就完全相同了。如何剥离，分析代码时遇到type_traits相关的含有类型特性的类只看成是类型特性，跟类型特性无关的全都忽略掉。

    另附相关测试代码：

// my_type_traits.h开始

#ifndef MY_TYPE_TRAITS_H

#define MY_TYPE_TRAITS_H

 

struct my_true_type {

};

 

struct my_false_type {

};

 

template <class T>

struct my_type_traits

{

    typedef my_false_type has_trivial_destructor;

};

 

template<> struct my_type_traits<int>

{

    typedef my_true_type has_trivial_destructor;

};

 

#endif

// my_type_traits.h结束

 

// my_destruct.h开始

#ifndef MY_DESTRUCT_H

#define MY_DESTRUCT_H

#include <iostream>

 

#include "my_type_traits.h"

 

using std::cout;

using std::endl;

 

template <class T1, class T2>

inline void myconstruct(T1 *p, const T2& value)

{

    new (p) T1(value);

}

 

template <class T>

inline void mydestroy(T *p)

{

    typedef typename my_type_traits<T>::has_trivial_destructor trivial_destructor;

    _mydestroy(p, trivial_destructor());

}

 

template <class T>

inline void _mydestroy(T *p, my_true_type)

{

    cout << " do the trivial destructor " << endl;

}

 

template <class T>

inline void _mydestroy(T *p, my_false_type)

{

    cout << " do the real destructor " << endl;

    p->~T();

}

 

#endif

// my_destruct.h结束

 

// test_type_traits.cpp开始

#include <iostream>

#include "my_destruct.h"

 

using std::cout;

using std::endl;

 

class TestClass

{

public:

    TestClass()

    {

        cout << "TestClass constructor call" << endl;

        data = new int(3);

    }

    TestClass(const TestClass& test_class)

    {

        cout << "TestClass copy constructor call. copy data:"

            << *(test_class.data) << endl;

        data = new int;

        *data = *(test_class.data) * 2;

    }

    ~TestClass()

    {

        cout << "TestClass destructor call. delete the data:" << *data << endl;

        delete data;

    }

private:

    int *data;

};

 

int main(void)

{

    {

        TestClass *test_class_buf;

        TestClass test_class;

 

        test_class_buf = (TestClass *)malloc(sizeof(TestClass));

        myconstruct(test_class_buf, test_class);

        mydestroy(test_class_buf);

        free(test_class_buf);

    }

 

    {

        int *int_p;

        int_p = new int;

        mydestroy(int_p);

        free(int_p);

    }

}

// test_type_traits.cpp结束