C++ traits技术浅谈

前言


 

  traits,又被叫做特性萃取技术,说得简单点就是提取“被传进的对象”对应的返回类型,让同一个接口实现对应的功能。因为STL的算法和容器是分离的,两者通过迭代器链接。算法的实现并不知道自己被传进来什么。萃取器相当于在接口和实现之间加一层封装,来隐藏一些细节并协助调用合适的方法,这需要一些技巧(例如,偏特化)。最后附带一个小小的例子,应该能更好地理解
特性萃取。

  下面大部分来源于《STL源码剖析》,看原书能了解更多细节。

 

Traits编程技法


  让我们一点点抛出问题,然后一点点深入。

  1.
首先,在算法中运用迭代器时,很可能会用到其相应型别(迭代器所指之物的型别)。假设算法中有必要声明一个变量,以“迭代器所指对象的型别”为型别,该怎么办呢?

  解决方法是:利用function template的参数推导机制。

 1 template <class I, class T> 2 void func_impl(I iter, T t) { 3 T tmp; // 这里就是迭代器所指物的类型新建的对象 4 // ... 功能实现 5 } 6 7 template <class I> 8 inline 9 void func(I iter) {10 func_impl(iter, *iter); // 传入iter和iter所指的值,class自动推导11 }12 13 int main() {14 int i;15 func(&i);16 }

  这里已经可以看出封装的意思了,没有一层impl的封装的话,每次你都要显式地说明迭代器指向对象型别,才能新建tmp变量。加一层封装显得清爽很多。

  迭代器相应型别不只是“迭代器所指对象的型别”一种而已。根据经验,最常用的相应型别有五种,然而并非任何情况下任何一种都可以利用上述的template参数推导机制来取得。

  函数的“template参数推导机制”推导的只是参数,无法推导函数的返回值类型。万一需要推导函数的传回值,就无能为力了。

 

  2.  声明内嵌型别似乎是个好主意,这样我们就可以直接获取。

 1 template <class T> 2 struct MyIter { 3 typedef T value_type; // 内嵌型别声明 4 // ... 5 }; 6 7 template <class I> 8 typename I::value_type 9 func(I ite) {10 return *ite;11 }12 13 // ...14 MyIter<int> ite(new int(8));15 cout << func(ite);

  看起来不错,但是并不是所有迭代器都是class
type,原生指针就不行!如果不是class type,就无法为它定义内嵌型别。

  这时候就需要 偏特化 出现。

 

  3. 偏特化就是在特化的基础上再加一点限制,但它还是特化的template。

 1 template <class I> 2 struct iterator_traits { 3 typedef typename I::value_type value_type; 4 }; 5 6 template <class I> 7 struct iterator_traits<T*> { 8 typedef T value_type; 9 };10 11 template <class I>12 typename iterator_traits<I>::value_type13 func(I ite) {14 return *ite;15 }

  func在调用 I 的时候,首先把 I 传到萃取器中,然后萃取器就匹配最适合的
value_type。(萃取器会先匹配最特别的版本)这样当你传进一个原生指针的时候,首先匹配的是带<T*>的偏特化版本,这样
value_type 就是 T,而不是没有事先声明的
I::value_type。这样返回值就可以使用 typename
iterator_traits<I>::value_type 来知道返回类型。

  下面附上《STL源码剖析》的图片:

图片 1

 

让traits干更多东西


 

  迭代器有常见有五种类型: value_type, difference_type,
reference_type, pointer_type都比较容易在 traits 和
相应偏特化中提取。但是,iterator_category一般也有5个,这个相应型别会引发较大规模的写代码工程。

  例如,我们实现了 func_II, func_BI, func_RAI
分别代表迭代器类型是Input Iterator,Bidirectional Iterator和Random
Access Iterator的对应实现。

  现在,当客端调用func()的时候,我们可能需要做一个判断:

1 template<class Iterator>2 void func(Iterator& i) {3 if (is_random_access_iterator(i))4 func_RAI(i);5 if (is_bidirectional_iterator(i))6 func_BI(i);7 else8 func_II(i);9 }

  但这样在执行时期才决定使用哪一个版本,会影响程序效率。最好能够在编译期就选择正确的版本。

  重载这个函数机制可以达成这个目标。

1 struct input_iterator_tag {};2 struct output_iterator_tag {};3 struct forward_iterator_tag : public input_iterator_tag {};4 // ...5 // 继承的好处就是,当函数需要用 input_iterator_tag 的时候6 // 假设你传进一个forward_iterator_tag,它会沿继承向上找,知道符合条件

 

   声明了一些列 tag 之后,我们就可以重载 func函数: func(tag)。

  到这里,各个型别的具体重载实现已经写好,但是需要一个统一的接口,这时候
traits 就可以出场了。

1 template<class Iterator>2 inline void func(Iterator& i)3 {4 typedef typename Iterator_traits<Iterator>::iterator_category category;5 __func(i, category()); // 各型别的重载6 }

 

 

简单实例代码


 

  所以说,traits一方面,在面对不同的输入类时,能找到合适的返回型别;另一方面,当型别对应有不同的实现函数的时候,能起到一个提取型别然后分流的作用。

  先假设我们有一个 func 函数,可以接受 自定义的类 或者 原始的指针
作为参数,并自动输出使用了什么tag。

  首先根据 traits(由本身或偏特化版本实现) ,它会提取 u
的返回型别,然后调用对应的构造函数 return_type(), 来当作各个重载版本
__func 的重载标志区分不同的实际函数。

  图片 2

  • 首先我们看看接口代码的编写

    1 template <class unknown_class>2 inline typename unknown_class_traits<unknown_class>::return_type // 萃取器取得对应型别3 func(unknown_class u) {4 typedef typename unknown_class_traits<unknown_class>::return_type return_type;5 return __func(u, return_type()); // 需要调用构造函数当tag6 }
  • 先 return_type 的构造函数

    1 template <class unknown_class>2 inline typename unknown_class_traits<unknown_class>::return_type3 return_type(unknown_class) {4 typedef typename unknown_class_traits<unknown_class>::return_type RT;5 return RT();6 }

    然后是实现设定的 tag ,用来模仿前面说的 II,RAI等

    1 struct A {};2 struct B : A{};
  • 然后是 traits 隆重登场,有两个偏特化版本。

     1 /*特性萃取器*/ 2 template <class unknown_class> 3 struct unknown_class_traits { 4 typedef typename unknown_class::return_type return_type; 5 }; 6 7 /*特性萃取器 —— 针对原生指针*/ 8 template <class T> 9 struct unknown_class_traits<T*> {10 typedef T return_type;11 };12 13 /*特性萃取其 —— 针对指向常数*/14 template <class T>15 struct unknown_class_traits<const T*> {16 typedef const T return_type;17 };
  • 突然忘记了交代 unknown_class 的结构,自定义的类,必须要 typedef。

    1 template <class AorB>2 struct unknown_class {3 typedef AorB return_type;4 };
  • 最后是func各个重载版本。

     1 template <class unknown_class> 2 inline typename unknown_class_traits<unknown_class>::return_type 3 __func(unknown_class, A) { 4 cout << "use A flag" << endl; 5 return A(); 6 } 7 8 template <class unknown_class> 9 inline typename unknown_class_traits<unknown_class>::return_type10 __func(unknown_class, B) {11 cout << "use B flag" << endl;12 return B();13 }14 15 template <class unknown_class, class T>16 T17 __func(unknown_class, T) {18 cout << "use origin ptr" << endl;19 return T();20 }

     

  • 有了这些我们就可以测试了

     1 int main() { 2 unknown_class<B> b; 3 unknown_class<A> a; 4 //unknown_class<int> i; 5 int value = 1; 6 int *p = &value; 7 8 A v1 = func(a); 9 B v2 = func(b);10 int v3 = func(p);11 12 char ch = getchar();13 } 

  可以看到,对于用自定义类传入同一个接口,它会自动使用对应的函数,而且返回值也合适。对原始指针也适用,完美!

图片 3

 


 

 下面是完整代码:

 1 #include <iostream> 2 using namespace std; 3 4 /*先定义一些tag*/ 5 struct A {}; 6 struct B : A{}; // 继承的好处就是,当函数需要参数为A, 7 // 而你传入的参数为B的时候,可以往上一直找到适合的对象 8 9 /*假设有一个未知类*/10 template <class AorB>11 struct unknown_class {12 typedef AorB return_type;13 };14 15 /*特性萃取器*/16 template <class unknown_class>17 struct unknown_class_traits {18 typedef typename unknown_class::return_type return_type;19 };20 21 /*特性萃取器 —— 针对原生指针*/22 template <class T>23 struct unknown_class_traits<T*> {24 typedef T return_type;25 };26 27 /*特性萃取其 —— 针对指向常数*/28 template <class T>29 struct unknown_class_traits<const T*> {30 typedef const T return_type;31 };32 33 34 /*决定使用哪一个类型*/35 template <class unknown_class>36 inline typename unknown_class_traits<unknown_class>::return_type37 return_type(unknown_class) {38 typedef typename unknown_class_traits<unknown_class>::return_type RT;39 return RT();40 }41 42 template <class unknown_class>43 inline typename unknown_class_traits<unknown_class>::return_type44 __func(unknown_class, A) {45 cout << "use A flag" << endl;46 return A();47 }48 49 template <class unknown_class>50 inline typename unknown_class_traits<unknown_class>::return_type51 __func(unknown_class, B) {52 cout << "use B flag" << endl;53 return B();54 }55 56 template <class unknown_class, class T>57 T58 __func(unknown_class, T) {59 cout << "use origin ptr" << endl;60 return T();61 }62 63 template <class unknown_class>64 inline typename unknown_class_traits<unknown_class>::return_type65 func(unknown_class u) {66 typedef typename unknown_class_traits<unknown_class>::return_type return_type;67 return __func(u, return_type());68 }69 70 int main() {71 unknown_class<B> b;72 unknown_class<A> a;73 //unknown_class<int> i;74 int value = 1;75 int *p = &value;76 77 A v1 = func(a);78 B v2 = func(b);79 int v3 = func(p);80 81 char ch = getchar();82 }

 

 结束语


  特性提取花了自己好多时间,不过当程序跑出来的瞬间还是挺开心的。

  首先要感谢侯捷老师,老师的书讲得这么清楚,我还是笨笨的看得一知半解。

  看完这个可以看图像的傅里叶变换啦,啊哈哈~

  

 

相关文章

Comment ()
评论是一种美德,说点什么吧,否则我会恨你的。。。