文章目录
1. 迭代器概念
1.1 基本概念
- 一种抽象的设计概念。在《Design Patterns》中有如下定义：
提供一种方法，使之能够依序巡访某个聚合物所含的各个元素，而又无需暴露该聚合物的内部表述方式
- 简单来说，迭代器可以让我们访问容器内部的元素，而我们又不需要知道内部是如何构造的
- 迭代器将容器与算法撮合在一起
- 迭代器最重要的工作就是对operator* 和operator->进行重载
1.2 迭代器设计理念
- 设计一个容器的迭代器，首先需要对容器的构造非常了解，就将迭代器的开发工作交给容器的设计者，这样就能将所有实现细节封装起来不被使用者看到
2. 引出traits编程
triats，译为特性，traits编程即为特征编程
- 由推导迭代器相应型别引出traits编程
- 利用
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);
}
int main()
{
int i;
func(&i); //调用模板，自动进行参数推导，导出型别T
}
- 此方法有一定的局限性，对于函数的返回值类型无法进行推导
- 声明
内嵌型别，利用该型别得出返回值类型
template <class T>
struct MyIter {
typedef T value_type;
T* ptr;
MyIter(T* p = 0) : ptr(p) {}
T& oeprator*() const { return *ptr; }
//...
};
template <class I>
typename I::value_type //一整行作为func的返回值类型，typename告诉编译器这是一个类型
func(I ite)
{
return *ite;
}
//....
MyIter<int> ite(new int(8));
cout << func(ite);
- 此方法亦有一定的局限性，即对于不是class type的迭代器而言，就无内嵌型别，亦无法推导
- 能不能找寻一种可以针对某种特定情况做出特定处理的方案呢？答案是可以的，template partial specialization->模板特例化可以做到
3. traits编程
3.1 traits编程技术
参考自pandening的博客
- traits编程技术就是利用内嵌型别以及通过模板的类型推导机制，获得变量的类型，而后决定dispatch到哪个函数
- 接下来首先得到迭代器的类型：
3.2 partial specialization（偏特化）
- 假设定义了一个类模板C：
template <typename T>
class C {...}; //允许接受T为任意类型
- 那么所谓的偏特化即指对template参数进行进一步的约束，但其本质仍然是模板：
template <typename T>
class C<T*> { .... }; //这个特化版本仅适用于“T为原生指针的情况
//”T为原生指针”即是对模板参数的再一次约束
3.3 traits
- 专门用来"萃取"迭代器的特性的一个模板类，可根据迭代器的类型不同进行特殊的特化：
template <class I>
struct iterator_traits {
typedef typename I::value_type value_type;
};
//迭代器是一个原生指针时
template <class T>
struct iterator_traits<T*> { //偏特化版，迭代器是个原生指针
typedef T value_type;
};
- 通过上述的方式进行构造，对于每一个特殊的迭代器均构造其偏特化版,通过“萃取”得出相应迭代器的特性
3.4 常用的迭代器型别
五种：value_type、difference_type、pointer、reference、iterator= catagoly
在模板类中定义如下：
template <class I>
struct iterator_traits {
typedef typename I::iterator_category iteerator_category;
typedef typename I::value_type value_type;
typedef typename I::difference_type difference_type;
typedef typename I::pointer pointer ;
typedef typename I::reference reference;
};
1. value type:指迭代器所指对象的型别
2. difference type:用来表示两个迭代器之间的距离
3. reference type:引用类型
4. pointer type:指针类型
5. iterator_category：根据移动与施行操作，又可分为5类
- Input Iterator： 只读迭代器
- Output Iterator：唯写
- Forward Iterator：允许“写入型“算法在此迭代器上进行读写操作
- Bidirectional Iterator：可双向移动
- Random Access Iterator：涵盖上述所有指针运算能力，随机的迭代器
3.5 dispatch到函数
- traits，一方面在面对不同的输入类的时候能够提取对应的型别；另一方面如果型别对应有不同的函数实现，则能起到提取型别并分流的作用
- 以下做了一个测试版本：
#include <iostream>
using namespace std;
//定义tag
struct A {};
struct B : public A {}; //1.以类来定义迭代器的各种分类标签，不仅可以促成重载机制的成功运作
struct C : public B {}; //2.通过继承，可以不必再写“单纯只做传递调用的函数
//定义一个类，里面定义型别
template <class T>
struct Definition {
typedef T Judgement_type;
};
//特性萃取器
template <class Definition>
struct Definition_traits {
typedef typename Definition::Judgement_type Judgement_type;
};
//特性萃取器-针对原生指针版本
template <class T>
struct Definition_traits<T*> {
typedef T Judgement_type;
};
//特性萃取器-针对常量指针版本
template <class T>
struct Definition_traits<const T*> {
typedef const T Judgement_type;
};
//这个函数可以很方便地决定某个迭代器地类型
template <class Definition>
inline typename Definition_traits<Definition>::Judgement_type
Judgement_type(Definition){
typedef typename Definition_traits<Definition>::Judgement_type JT;
return JT();
}
//以下是整组func测试函数
template <class Definition>
inline typename Definition_traits<Definition>::Judgement_type
_func(Definition, A) {
cout << "A tag()" << endl;
return A();
}
//以下重载函数，根据型别dispatch
template <class Definition>
inline typename Definition_traits<Definition>::Judgement_type
_func(Definition, B) {
cout << "B tag()" << endl;
return B();
}
template <class Definition>
inline typename Definition_traits<Definition>::Judgement_type
_func(Definition, C) {
cout << "C tag()" << endl;
return C();
}
template <class Definition, class T>
inline T
_func(Definition, T) {
cout << "origin ptr" << endl;
return T();
}
template <class Definition>
inline typename Definition_traits<Definition>::Judgement_type
func(Definition u) {
typedef typename Definition_traits<Definition>::Judgement_type Judgement_type;
return _func(u, Judgement_type());
}
int main()
{
Definition<A> a;
Definition<B> b;
Definition<C> c;
int *p = NULL;
func(a);
func(b);
func(c);
func(p);
return 0;
}
- 理解了这一个实现大概就能理解traits编程的作用
4. traits的第二个应用–__type_traits
iterator_traits萃取迭代器的属性，__type_traits萃取型别的属性，根据不同的型别属性，在编译时期完成函数的派送决定
- 由于我们在上面已经详述了关于traits编程，在这里就不多分析；来分析一下__type_traits如何判断是否有trivial（不重要的）函数：
如果至少满足一下3条中的一条：
- 显示(explict)地定义了这四种函数，ctor、copy、assignment、dtor
- 类里有非静态非POD地数据成员，如string
- 有基类
那么上面四种函数是non-trivial ctor，non-trivial copy…（即有意义的函数），如果该类都是trivial函数，则可在对该型别构造、析构、拷贝、赋值操作时采用最有效率的措施
5. 总结
为什么想写这个总结呢？因为在上述理解traits编程时出现了一点小trouble，可能上面写的有点乱，因此想写个总结重新梳理一下
1.首先了解了迭代器在STL中的重要性以及迭代器这一设计模式
2.由于C++没有获得对象型别的直接方法，因此在尝试了模板参数推导、内嵌型别方法之后，引出了traits编程
3.traits编程，利用内嵌型别以及通过模板的类型推导机制，获得变量的类型，而后决定dispatch到哪个函数
4.traits编程技巧在STL中的应用：iterator_traits,__type_traits