前言
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_type 13 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源码剖析》的图片：
让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 else 8 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 的重载标志区分不同的实际函数。
- 首先我们看看接口代码的编写
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()); // 需要调用构造函数当tag 6 }
- 先 return_type 的构造函数
1 template <class unknown_class> 2 inline typename unknown_class_traits<unknown_class>::return_type 3 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_type 10 __func(unknown_class, B) { 11 cout << "use B flag" << endl; 12 return B(); 13 } 14 15 template <class unknown_class, class T> 16 T 17 __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 }
可以看到，对于用自定义类传入同一个接口，它会自动使用对应的函数，而且返回值也合适。对原始指针也适用，完美！
附
下面是完整代码：
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_type 37 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_type 44 __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_type 51 __func(unknown_class, B) { 52 cout << "use B flag" << endl; 53 return B(); 54 } 55 56 template <class unknown_class, class T> 57 T 58 __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_type 65 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 }
结束语
特性提取花了自己好多时间，不过当程序跑出来的瞬间还是挺开心的。
首先要感谢侯捷老师，老师的书讲得这么清楚，我还是笨笨的看得一知半解。
看完这个可以看图像的傅里叶变换啦，啊哈哈~