traits的应用场合

模板（泛型）实际上就是宏定义一个类型，此类型是一个通用类型（故又叫泛型），把具体类型(包括指针类型)带入进去就会形成一个新的类型。下面是代入时两种编译错误的解决方法：

一、模板（泛型）具型成 int::valuetype 时（代入基本类型），这显然编译不过，就像下面这样偏特化处理

// my_type_traits.h开始
#ifndef MY_TYPE_TRAITS_H
#define MY_TYPE_TRAITS_H
 
struct my_true_type {
};
 
struct my_false_type {
};
 
template 
struct my_type_traits
{
    typedef my_false_type has_trivial_destructor;
};
 
template<> struct my_type_traits
{
    typedef my_true_type has_trivial_destructor;
};
 
#endif
// my_type_traits.h结束
 
// my_destruct.h开始
#ifndef MY_DESTRUCT_H
#define MY_DESTRUCT_H
#include 
 
#include "my_type_traits.h"
 
using std::cout;
using std::endl;
 
template 
inline void myconstruct(T1 *p, const T2& value)
{
    new (p) T1(value);
}
 
template 
inline void mydestroy(T *p)
{
    typedef typename my_type_traits::has_trivial_destructor trivial_destructor;
    _mydestroy(p, trivial_destructor());
}
 
template 
inline void _mydestroy(T *p, my_true_type)
{
    cout <<" do the trivial destructor " <}
 
template 
inline void _mydestroy(T *p, my_false_type)
{
    cout <<" do the real destructor " <    p->~T();
}
 
#endif
// my_destruct.h结束

// test_type_traits.cpp开始
#include 
#include "my_destruct.h"
 
using std::cout;
using std::endl;
 
class TestClass
{
public:
    TestClass()
    {
        cout <<"TestClass constructor call" <        data = new int(3);
    }
    TestClass(const TestClass& test_class)
    {
        cout <<"TestClass copy constructor call. copy data:"
            <<*(test_class.data) <        data = new int;
        *data = *(test_class.data) * 2;
    }
    ~TestClass()
    {
        cout <<"TestClass destructor call. delete the data:" <<*data <        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结束

二、模板（泛型）具型成 int*::valuetype 时（代入各种类型指针），这显然编译不过，就像下面这样偏特化处理

Traits技术可以用来获得一个 类型 的相关信息的。 首先假如有以下一个泛型的迭代器类，其中类型参数 T 为迭代器所指向的类型：

template  < typename  T>
class  myIterator
{
 ...
};

当我们使用myIterator时，怎样才能获知它所指向的元素的类型呢？我们可以为这个类加入一个内嵌类型，像这样：
template  < typename  T>
class  myIterator
{
       typedef   T value_type; 
...
};
这样当我们使用myIterator类型时，可以通过 myIterator::value_type来获得相应的myIterator所指向的类型。

现在我们来设计一个算法，使用这个信息。
template 
typename  myIterator::value_type Foo(myIterator i)
{
 ...
}
这里我们定义了一个函数Foo，它的返回为为  参数i 所指向的类型，也就是T，那么我们为什么还要兴师动众的使用那个value_type呢？ 那是因为，当我们希望修改Foo函数，使它能够适应所有类型的迭代器时，我们可以这样写：
template    //这里的I可以是任意类型的迭代器
typename  I::value_type Foo(I i)
{
 ...
}
现在，任意定义了 value_type内嵌类型的迭代器都可以做为Foo的参数了，并且Foo的返回值的类型将与相应迭代器所指的元素的类型一致。至此一切问题似乎都已解决，我们并没有使用任何特殊的技术。然而当考虑到以下情况时，新的问题便显现出来了：

原生指针也完全可以做为迭代器来使用，然而我们显然没有办法为原生指针添加一个value_type的内嵌类型，如此一来我们的Foo()函数就不能适用原生指针了，这不能不说是一大缺憾。那么有什么办法可以解决这个问题呢？ 此时便是我们的主角：类型信息榨取机 Traits 登场的时候了

....drum roll......

我们可以不直接使用myIterator的value_type，而是通过另一个类来把这个信息提取出来：
template  < typename  T>
class Traits
{
       typedef   typename  T::value_type value_type;
};
这样，我们可以通过 Traits::value_type 来获得myIterator的value_type，于是我们把Foo函数改写成：
template    //这里的I可以是任意类型的迭代器
typename  Traits::value_type Foo(I i)
{
 ...
}
然而，即使这样，那个原生指针的问题仍然没有解决，因为Trait类一样没办法获得原生指针的相关信息。于是我们祭出C++的又一件利器--偏特化(partial specialization)：
template  < typename  T>
class Traits  //注意 这里针对原生指针进行了偏特化
{
       typedef   typename  T value_type;
};
通过上面这个 Traits的偏特化版本，我们陈述了这样一个事实：一个 T* 类型的指针所指向的元素的类型为 T。

如此一来，我们的 Foo函数就完全可以适用于原生指针了。比如：
int  * p;
....
int  i = Foo(p);
Traits会自动推导出 p 所指元素的类型为 int，从而Foo正确返回。