Traits 萃取技术与迭代器设计原则

  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。

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

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 就可以出场了。

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 }

  • 有了这些我们就可以测试了
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();
}

在STL标准库中主要包含五种设计的原则属性,其中pointer和reference是很少使用的。 

  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STL实现迭代器萃取的方式是通过对iterator_traits进行偏特化。为了使迭代器萃取有效运行,每个迭代器都要自行以内嵌性别定义的方式定义出相应的型别。迭代器的类型萃取机制被定义为iterator_traits模板类,它接受一个迭代器类型作为模板参数,并通过特化来提取迭代器的相关信息。 在STL中,对于一般的迭代器类型,使用iterator_traits模板类进行萃取,通过迭代器的内嵌typedef来获取iterator_category、value_type、difference_type、pointer和reference等相应的型别。而针对原生指针类型的迭代器STL会针对指针类型进行偏特化,直接定义出相应的型别,如random_access_iterator_tag、_Tp、ptrdiff_t、_Tp*和_Tp&等。这样就可以实现对迭代器的属性萃取。 通过对iterator_traits进行偏特化,STL能够根据不同的迭代器类型提取出相应的属性,从而能够在算法中正确地使用不同类型的迭代器,并根据迭代器的属性进行相应的操作。这样实现了迭代器的通用性和灵活性,使得STL算法可以适用于不同类型的迭代器。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [STL迭代器---萃取](https://blog.csdn.net/jiewaikexue/article/details/111372288)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [STL 迭代器萃取](https://blog.csdn.net/qq_40080842/article/details/128112675)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值