C++中traits技术的示例分析

这篇文章主要介绍了C++中traits技术的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

Traits编程技法

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

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

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

template <class I, class T> void func_impl(I iter, T t) {         T tmp; // 这里就是迭代器所指物的类型新建的对象         // ... 功能实现 } template <class I> inline void func(I iter) {         func_impl(iter, *iter); // 传入iter和iter所指的值，class自动推导 } int main() {     int i;     func(&i); }

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

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

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

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

template <class T> struct MyIter {     typedef T value_type; // 内嵌型别声明     // ... }; template <class I> typename I::value_type func(I ite) {     return *ite; } // ... MyIter<int> ite(new int(8)); cout << func(ite);

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

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

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

 template <class I>   struct iterator_traits {       typedef typename I::value_type value_type;   };      template <class I>   struct iterator_traits<T*> {       typedef T value_type;   };    template <class I>12 typename iterator_traits<I>::value_type  func(I ite) {      return *ite;  }

　　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()的时候，我们可能需要做一个判断：

template<class Iterator> void func(Iterator& i) {     if (is_random_access_iterator(i))         func_RAI(i);     if (is_bidirectional_iterator(i))         func_BI(i);     else         func_II(i); }

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

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

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

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

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

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

简单实例代码

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

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

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

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

 template <class unknown_class>  inline typename unknown_class_traits<unknown_class>::return_type // 萃取器取得对应型别  func(unknown_class u) {      typedef typename unknown_class_traits<unknown_class>::return_type return_type;      return __func(u, return_type()); // 需要调用构造函数当tag  }

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

 template <class unknown_class>  inline typename unknown_class_traits<unknown_class>::return_type  return_type(unknown_class) {      typedef typename unknown_class_traits<unknown_class>::return_type RT;      return RT();  }

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

struct A {}; struct B : A{};

然后是 traits 隆重登场，有两个偏特化版本。

/*特性萃取器*/ template <class unknown_class> struct unknown_class_traits {     typedef typename unknown_class::return_type return_type; }; /*特性萃取器 —— 针对原生指针*/ template <class T> struct unknown_class_traits<T*> {     typedef T return_type; }; /*特性萃取其 —— 针对指向常数*/ template <class T> struct unknown_class_traits<const T*> {     typedef const T return_type; };

突然忘记了交代 unknown_class 的结构，自定义的类，必须要 typedef。

 template <class AorB> struct unknown_class {    typedef AorB return_type; };

最后是func各个重载版本。

template <class unknown_class> inline typename unknown_class_traits<unknown_class>::return_type __func(unknown_class, A) {     cout << "use A flag" << endl;     return A(); } template <class unknown_class> inline typename unknown_class_traits<unknown_class>::return_type __func(unknown_class, B) {     cout << "use B flag" << endl;     return B(); } template <class unknown_class, class T> T __func(unknown_class, T) {     cout << "use origin ptr" << endl;     return T(); }

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

int main() {     unknown_class<B> b;     unknown_class<A> a;     //unknown_class<int> i;     int value = 1;     int *p = &value;     A v1 = func(a);     B v2 = func(b);     int v3 = func(p);     char ch = getchar(); }

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

附

下面是完整代码：

#include <iostream> using namespace std; /*先定义一些tag*/ struct A {}; struct B : A{}; // 继承的好处就是，当函数需要参数为A，                 // 而你传入的参数为B的时候，可以往上一直找到适合的对象 /*假设有一个未知类*/ template <class AorB> struct unknown_class {     typedef AorB return_type; }; /*特性萃取器*/ template <class unknown_class> struct unknown_class_traits {     typedef typename unknown_class::return_type return_type; }; /*特性萃取器 —— 针对原生指针*/ template <class T> struct unknown_class_traits<T*> {     typedef T return_type; }; /*特性萃取其 —— 针对指向常数*/ template <class T> struct unknown_class_traits<const T*> {     typedef const T return_type; }; /*决定使用哪一个类型*/ template <class unknown_class> inline typename unknown_class_traits<unknown_class>::return_type return_type(unknown_class) {     typedef typename unknown_class_traits<unknown_class>::return_type RT;     return RT(); } template <class unknown_class> inline typename unknown_class_traits<unknown_class>::return_type __func(unknown_class, A) {     cout << "use A flag" << endl;     return A(); } template <class unknown_class> inline typename unknown_class_traits<unknown_class>::return_type __func(unknown_class, B) {     cout << "use B flag" << endl;     return B(); } template <class unknown_class, class T> T __func(unknown_class, T) {     cout << "use origin ptr" << endl;     return T(); } template <class unknown_class> inline typename unknown_class_traits<unknown_class>::return_type func(unknown_class u) {     typedef typename unknown_class_traits<unknown_class>::return_type return_type;     return __func(u, return_type()); } int main() {     unknown_class<B> b;     unknown_class<A> a;     //unknown_class<int> i;     int value = 1;     int *p = &value;     A v1 = func(a);     B v2 = func(b);     int v3 = func(p);     char ch = getchar(); }

感谢你能够认真阅读完这篇文章，希望小编分享的“C++中traits技术的示例分析”这篇文章对大家有帮助，同时也希望大家多多支持亿速云，关注亿速云行业资讯频道，更多相关知识等着你来学习!