您的位置: 首页  >  IT文章  >  Traits编程技法

Traits编程技法

分类: IT文章 • 2022-06-01 12:39:00

    迭代器所指对象的型别，称为该迭代器的value type。value type是迭代器相应型别的一种。想要知道迭代器的value type，下面是一种办法：

 1 template <class T>
 2 struct MyIter{
 3     typedef T value_type;
 4     T* ptr;
 5     //....
 6 };
 7 
 8 template <class I>
 9 typename I::value_type
10 func(I ite)
11 {  return *ite; }

 但当func参数为原生指针时上述办法就不适用了。偏特化可以解决，所谓partial specialization的意思是提供另一份template的定义，其本身仍为templatized。

1 template<typename T>
2 class C {  ...  };
3 
4 //特化版本，使用于T为原生指针
5 template<typename T>
6 class C<T*> {  ...  };

    专门定义一个class template用来萃取迭代器的特性：

1 template <class I>
2 struct iterator_traits {
3     typedef typename I::value_type value_type;
4 };

 这样使用iterator_traits<I>::value_type，实际上就是I::value_type,使用：

1 template <class I>
2 typename iterator_traits<I>::value_type
3 func(I ite)
4 {  return *ite; }

可以针对原生指针提供一个特化版本：

1 template <class T>
2 struct iterator_traits<T*> {
3     typedef T value_type;
4 };

故即使原生指针int*不是一种class type，仍可以通过iterator_traits<int*>::value_type萃取出其value type。

    根据经验，最常用到的迭代器相应型别有五种：

1 template <class I>
2 struct iterator_traits {
3     typedef typename I::iterator_category iterator_category;
4     typedef typename I::value_type value_type ;
5     typedef typename I::difference_type difference_type ;
6     typedef typename I::pointer pointer ;
7     typedef typename I::reference reference ;
8 };

iterator_traits必须针对传入之型别为pointer及pointer-to-const者，设计特化版本。


iterator_category

    迭代器可以分为五类：

　　　　Input Iterator：只读。

　　　　Output Iterator：只写。

　　　　Forward Iterator

　　　　Bidirectional Iterator

　　　　Random Access Iterator

上述的迭代器前两种往后依次强化，即后者支持前者支持的操作，且支持新的操作（前三种支持operator++,第四个加上operator--，最后一个涵盖所有指针的能力）。设计算法时，针对某种迭代器提供一个明确的定义，并针对更强化的某种迭代器提供另一种定义。例如，有个算法可以接受Forward Iterator，Random Access Iterator给它当然也可以接受，但由于算法在实现时只使用了Forward Iterator支持的操作，没有使用Random Access Iterator支持的更加便捷的操作，会导致效率低，故应该再定义一个Random Access Iterator版本的。

定义五个classes，代表五种迭代器类型：

1 struct input_iterator_tag { };
2 struct output_iterator_tag { };
3 struct forward_iterator_tag : public input_iterator_tag  { };
4 struct bidirectional_iterator_tag : forward_iterator_tag  { };
5 struct random_access_iterator_tag : bidirectional_iterator_tag  { };

 定义以下重载函数：

 1 template <class InputIterator, class Distance>
 2 inline void __advance(InputIterator& i, Distance n, input_iterator_tag)
 3 {
 4     while (n--)  ++i;
 5 }
 6 
 7 template <class BidirectionalIterator, class Distance>
 8 inline void __advance(BidirectionalIterator& i, Distance n, bidirectional_iterator_tag)
 9 {
10     if (n >= 0)
11         while (n--)  ++i;
12     else
13         while (n++)  --i;
14 }
15 
16 template <class RandomAccessIterator, class Distance>
17 inline void __advance(BidirectionalIterator& i, Distance n, random_access_iterator_tag)
18 {
19     i += n;
20 }

 每个__advance()的最后一个参数都只声明参数的类型，并未制定参数名称，因为它只是用来激活重载，函数里用不到该参数。接下来需要一个对外的接口，它接受两个参数，当它准备调用__advance()时，加上第三个参数：迭代器类型，这个工作要依赖于traits机制：

1 template <class InputIterator, class Distance>
2 inline void advance(InputIterator& i, Distance n)
3 {
4     __advance(i, n, iterator_traits<InputIterator>::iterator_category());
5 }

traits除了上面提供的class的迭代器类型，针对指针的特化版本：

 1 template <class T>
 2 struct iterator_traits<T*> {
 3      ...
 4      typedef random_access_iterator_tag iterator_category ;
 5  };
 6 
 7 template <class T>
 8 struct iterator_traits<const T*> {
 9      ...
10      typedef random_access_iterator_tag iterator_category ;
11  };

STL算法的一个命名规则：以算法所能接受之最低阶迭代器类型，来为其迭代器型别参数命名。

__type_traits

    STL只对迭代器加以规范，制定出iterator_traits，SGI把这种技法进一步扩大，于是有了__type_traits：

1 template <class type>
2 struct __type_traits {
3     typedef __true_type  this_dummy_member_must_be_first;
4     typedef __false_type  has_trivial_default_constructor;
5     typedef __false_type  has_trivial_copy_constructor;
6     typedef __false_type  has_trivial_assignment_operator;
7     typedef __false_type  has_trivial_destructor;
8     typedef __false_type  is_POD_type;
9 };

特化版本：

 1 template <class type>
 2 struct __type_traits<char> {
 3     typedef __true_type  has_trivial_default_constructor;
 4     typedef __true_type  has_trivial_copy_constructor;
 5     typedef __true_type  has_trivial_assignment_operator;
 6     typedef __true_type  has_trivial_destructor;
 7     typedef __true_type  is_POD_type;
 8 };
 9 
10 template <class type>
11 struct __type_traits<signed char> {
12     typedef __true_type  has_trivial_default_constructor;
13     typedef __true_type  has_trivial_copy_constructor;
14     typedef __true_type  has_trivial_assignment_operator;
15     typedef __true_type  has_trivial_destructor;
16     typedef __true_type  is_POD_type;
17 };
18 
19 template <class type>
20 struct __type_traits<unsigned char> {
21     typedef __true_type  has_trivial_default_constructor;
22     typedef __true_type  has_trivial_copy_constructor;
23     typedef __true_type  has_trivial_assignment_operator;
24     typedef __true_type  has_trivial_destructor;
25     typedef __true_type  is_POD_type;
26 };
27 
28 template <class type>
29 struct __type_traits<short> {
30     typedef __true_type  has_trivial_default_constructor;
31     typedef __true_type  has_trivial_copy_constructor;
32     typedef __true_type  has_trivial_assignment_operator;
33     typedef __true_type  has_trivial_destructor;
34     typedef __true_type  is_POD_type;
35 };
36 
37 template <class type>
38 struct __type_traits<unsigned short> {
39     typedef __true_type  has_trivial_default_constructor;
40     typedef __true_type  has_trivial_copy_constructor;
41     typedef __true_type  has_trivial_assignment_operator;
42     typedef __true_type  has_trivial_destructor;
43     typedef __true_type  is_POD_type;
44 };
45 
46 //后面省略int, unsigned int, long, unsigned long, float, double, long double, T*.....

使用示例：

 1 template <class T> inline void copy(T* source, T* destination, int n){
 2     copy(source, destination, __type_traits<T>::has_trivial_copy_constructor());
 3 }
 4 
 5 template <class T> inline void copy(T* source, T* destination, int n, __false_type)
 6 {  ...  }
 7 
 8 //拷贝一个数组，其元素具有trivial copy constructors，可借助memcpy()
 9 template <class T> inline void copy(T* source, T* destination, int n, __true_type)
10 {  ...  }

相关推荐