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_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 }

结束语



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

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

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

  

时间: 2024-10-26 22:08:35

C++ traits技术浅谈的相关文章

.net中对象序列化技术浅谈

.net中对象序列化技术浅谈 2009-03-11 阅读2756评论2 序列化是将对象状态转换为可保持或传输的格式的过程.与序列化相对的是反序列化,它将流转换为对象.这两个过程结合起来,可以轻松地存储和传输数 据.例如,可以序列化一个对象,然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象.反之,反序列化根据流重新构造对象.此外还可以将对象序列化后保存到本地,再次运行的时候可以从本地文件 中“恢复”对象到序列化之前的状态.在.net中有提供了几种序列化的方式:二进制序列化

流媒体网站开发技术浅谈

流媒体网站开发技术浅谈(2012-02) 2012-03-02    新闻来源:武汉广电网 张方东 (黄陂区广播影视局事业技术科) 摘 要:随着有线和无线网络宽带的高速发展,人们不再满足于因特网中仅有的文字.图片等简单信息,而越来越希望看到更直观.更丰富的影视节目,流媒体网站因此应运而生.本文从流媒体概念.流媒体格式.流媒体文件制作.流媒体文件传输.流媒体文件发布及流媒体网站部署等方面对开发流媒体网站作了详细阐述. 关键词:流媒体 网站开发 部署 技术 1.概述 在网络上传输多媒体有下载和流式传

开发技术--浅谈文件操作与字符编码

开发|浅谈文件操作与字符编码 听说Python的文件操作很容易在某一些电脑上出问题,然而罪魁祸首就是字符编码.让我们来了解一些底层的编码方式. 前言 目前所有的文章思想格式都是:知识+情感. 知识:对于所有的知识点的描述.力求不含任何的自我感情色彩. 情感:用我自己的方式,解读知识点.力求通俗易懂,完美透析知识. 正文 本文主要分为两大部分,一部分是如何使用Python进行文件操作,另一部分是聊一下字符编码的那些事.(比较绕,尽量用最最最通俗的话表述~~) 文件操作 1.文件操作方式 open(

开发技术--浅谈Python函数

开发|浅谈Python函数 函数在实际使用中有很多不一样的小九九,我将从最基础的函数内容,延伸出函数的高级用法.此文非科普片~~ 前言 目前所有的文章思想格式都是:知识+情感. 知识:对于所有的知识点的描述.力求不含任何的自我感情色彩. 情感:用我自己的方式,解读知识点.力求通俗易懂,完美透析知识. 正文 首先介绍函数是什么,接着走进函数,并且发现函数的高级使用方法,最后列出常用的Python的内置函数. 函数是什么? 1.函数,在代码执行的是不执行,只有在调用函数的时候才会执行. 2.函数使用

开发技术--浅谈python数据类型

开发|浅谈python数据类型 在回顾Python基础的时候,遇到最大的问题就是内容很多,而我的目的是回顾自己之前学习的内容,进行相应的总结,所以我就不玩基础了,很多在我实际生活中使用的东西,我会在文章中提一下.并且我自己会根据这些内容进行相应的补充与扩展. 文章定位:不是科普文,是自己对于自己学习的总结. 前言 目前所有的文章思想格式都是:知识+情感. 知识:对于所有的知识点的描述.力求不含任何的自我感情色彩. 情感:用我自己的方式,解读知识点.力求通俗易懂,完美透析知识. 正文 正文的主要内

虚拟机保护技术浅谈

转载于看雪论坛 对加密与解密的内容进行了一些总结.重新归纳整理,加入了自己的理解:希望对新手有所帮助. <加密与解密>第三版  第471页虚拟机保护技术  虚拟机概览     所谓虚拟机保护技术,是指将代码翻译为机器和人都无法识别的一串伪代码字节流:在具体执行时再对这些伪代码进行一一翻译解释,逐步还原为原始代码并执行.     这段用于翻译伪代码并负责具体执行的子程序就叫作虚拟机VM(好似一个抽象的CPU).它以一个函数的形式存在,函数的参数就是字节码的内存地址.     将虚拟机应用到商业中

Node.JS + MongoDB技术浅谈

看到一个Node.JS + MongoDB的小样例,分享给大家.魔乐科技软件学院(www.mldnjava.cn)的讲座 Node.JS + MongoDB技术讲座          云计算 +大数据 = 未来. 在中国的云计算上基本上是一个概念,个人感觉与当初的SOA没有太大的差别,空泛的理论. 中小型开发的未来 = Node.JS + MongoDB解决,并非说Java就没用了. 1.在前面的话 Java技术始终作为高端软件用户的首选,仅仅要从事大型的软件开发,那么Java都是必需要使用的技

[技术]浅谈重载操作符

前言 重载操作符可以成为强有力的工具,但不可抛弃与客户的契约而滥用,那样只会让程序更难让人理解. ——<c++面向对象高效编程> 背景 XXX:诶,你快过来 博主:蛤蛤蛤?怎么了? XXX:你教教我那个星号,不是,乘号怎么打啊 博主:乘号怎么打是什么意思啊 喵喵喵 XXX:就是可以让这两个矩阵乘起来啊 博主:...你不会是在说重载吧 XXX:对啊= = 博主:等我给你写完this,就来写重载 基本介绍&引入 照例引度娘: 操作符重载,计算机学科概念,就是把已经定义的.有一定功能的操作符

[技术]浅谈初始化语义与赋值语义

背景 博主是一个常年使用初始化语义的coder= =,所以经常会遇到这样的对话 int tmp(0); XXX:诶,你这tmp函数是干什么的啊 博主:蛤?我哪里定义了tmp函数了 XXX:那你这个是什么啊 博主:初始化啊,跟你打这个鬼东西是一样的啊 int tmp=0; XXX:蛤蛤蛤? 然后两人都陷入了茫然状态= = 基本介绍 观察这两行代码 string tmp1("2333"); string tmp2="666"; 有什么区别呢(不要说一个打的丑,一个打的优