c/c++语言开发共享深入浅析C++ traits技术

前言  traits,又被叫做特性萃取技术,说得简单点就是提取“被传进的对象”对应的返回类型,让同一个接口实现对应的功能。因为stl的算法和容器是分离的,两者通过迭代器链接。算法的实现并不知道自己被传


前言

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

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

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源码剖析》的图片:

深入浅析C++ traits技术

让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 的重载标志区分不同的实际函数。

  深入浅析C++ traits技术

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

   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();  }

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

深入浅析C++ traits技术

下面是完整代码:

  #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技术浅谈的详细内容,更多关于c++ traits技术的资料请关注<计算机技术网(www.ctvol.com)!!>其它相关文章!

需要了解更多c/c++开发分享深入浅析C++ traits技术,都可以关注C/C++技术分享栏目—计算机技术网(www.ctvol.com)!

本文来自网络收集,不代表计算机技术网立场,如涉及侵权请联系管理员删除。

ctvol管理联系方式QQ:251552304

本文章地址:https://www.ctvol.com/c-cdevelopment/627331.html

(0)
上一篇 2021年5月29日
下一篇 2021年5月29日

精彩推荐