C++ traits编程方法

转自： http://s99f.blog.163.com/blog/static/35118365200903111941380/

 

侯捷老师在《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;

: 9pt">        mydestroy(int_p);
        free(int_p);
    }
}
// test_type_traits.cpp结束
文章出处：http://www.diybl.com/course/3_program/c++/cppjs/2007918/71936_3.html

 

今天看"modern c++ design"的时候发现自己竟然又把以前好不容易弄懂的Traits技术给忘记了，真是...又重新学习了一下，赶紧记下来。
Traits技术可以用来获得一个 类型 的相关信息的。 首先假如有以下一个泛型的迭代器类，其中类型参数 T 为迭代器所指向的类型：

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

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

现在我们来设计一个算法，使用这个信息。
template <typename T>
typename myIterator<T>::value_type Foo(myIterator<T> i)
{
 ...
}
这里我们定义了一个函数Foo，它的返回为为  参数i 所指向的类型，也就是T，那么我们为什么还要兴师动众的使用那个value_type呢？ 那是因为，当我们希望修改Foo函数，使它能够适应所有类型的迭代器时，我们可以这样写：
template <typename I> //这里的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<myIterator>::value_type 来获得myIterator的value_type，于是我们把Foo函数改写成：
template <typename I> //这里的I可以是任意类型的迭代器
typename Traits<I>::value_type Foo(I i)
{
 ...
}
然而，即使这样，那个原生指针的问题仍然没有解决，因为Trait类一样没办法获得原生指针的相关信息。于是我们祭出C++的又一件利器--偏特化(partial specialization)：
template <typename T>
class Traits<T*> //注意 这里针对原生指针进行了偏特化
{
      typedef typename T value_type;
};
通过上面这个 Traits的偏特化版本，我们陈述了这样一个事实：一个 T* 类型的指针所指向的元素的类型为 T。

如此一来，我们的 Foo函数就完全可以适用于原生指针了。比如：
int * p;
....
int i = Foo(p);
Traits会自动推导出 p 所指元素的类型为 int，从而Foo正确返回。
今天看"modern c++ design"的时候发现自己竟然又把以前好不容易弄懂的Traits技术给忘记了，真是...又重新学习了一下，赶紧记下来。
Traits技术可以用来获得一个 类型 的相关信息的。 首先假如有以下一个泛型的迭代器类，其中类型参数 T 为迭代器所指向的类型：

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

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

现在我们来设计一个算法，使用这个信息。
template <typename T>
typename myIterator<T>::value_type Foo(myIterator<T> i)
{
 ...
}
这里我们定义了一个函数Foo，它的返回为为  参数i 所指向的类型，也就是T，那么我们为什么还要兴师动众的使用那个value_type呢？ 那是因为，当我们希望修改Foo函数，使它能够适应所有类型的迭代器时，我们可以这样写：
template <typename I> //这里的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<myIterator>::value_type 来获得myIterator的value_type，于是我们把Foo函数改写成：
template <typename I> //这里的I可以是任意类型的迭代器
typename Traits<I>::value_type Foo(I i)
{
 ...
}
然而，即使这样，那个原生指针的问题仍然没有解决，因为Trait类一样没办法获得原生指针的相关信息。于是我们祭出C++的又一件利器--偏特化(partial specialization)：
template <typename T>
class Traits<T*> //注意 这里针对原生指针进行了偏特化
{
      typedef typename T value_type;
};
通过上面这个 Traits的偏特化版本，我们陈述了这样一个事实：一个 T* 类型的指针所指向的元素的类型为 T。

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