c++ STL __type_traits<T>解释

今天看《STL源码剖析》，突然看到一个叫__type_traits<T>的名词。

当容器进行范围destoy的时候，其函数接受first和last的迭代器，若[first,last)范围内所有的元素都调用析构函数，但这个类型T的析构又是无关痛痒的，则会损耗效率。  __type_trais<T>可以判别该类型T的的析构函数是否无关痛痒，若是（__true_type），则什么都不做，否则调用其析构函数。

STL的destroy函数原型：

步骤解释：

1.首先容器触发destroy(Iterator first, Iterator last)

2.value_type(first)取得容器当前存储的类型T*，然后调用__destroy(Iterator first, Iterator last, T*)

3.在__destroy函数里， 利用typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor, 判断类型T的析构是否存在特性，并调用__destroy_aux,传入trivial_destructor

(若类型T是无特性的，其会定义typedef __true_type has_trivial_destructor, 否则定义typedef __false_type has_trivial_destructor)

4.若存在特性，则会调用到__destroy_aux(Iterator, Iterator, __false_type), 并逐一对[first, last)范围内的元素进行析构

5.若不存在特性，则会调用到__destroy_aux(Iterator, Iterator, __true_type), 并什么都不做

ps:更具体的理解可以看看http://blog.csdn.net/sanlongcai/article/details/1786647     该博文浅显地讲出了type trait的概念，而其测试代码也很容易懂。

此处顺便记录下本人对上述博文的测试代码的修改测试，供日后回味。 :)

#ifndef TEST_CLASS_H
#define TEST_CLASS_H

#include <iostream>
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;
};

#endif

// my_type_traits.h开始
#ifndef MY_TYPE_TRAITS_H
#define MY_TYPE_TRAITS_H

//#include "test_class.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;
};

//template<> struct my_type_traits<TestClass>
//{
//    typedef my_true_type has_trivial_destructor;
//}; //若删除对TestClass的注释，则TestClass将会被定义成没有特性的析构的类

#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; //此处获得类型T是否没有特性析构
    _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结束

#include "test_class.h"
#include "my_destruct.h"

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

该图是当my_type_traits.h中对TestClass的has_trivial_destructor定义为__true_type的语句注释后的结果

这是利用了偏特化（Partial Specialization）的做法

下图则是未注释的结果