STL容器-Traits与偏特化
Traits是STL中非常重要的一个技巧，主要是用来优化性能，在
STL空间配置器中有简单介绍，这里做一个更详细的介绍；Traits主要有两类：__type_traits和iterator_traits，对于构造和析构有着非常重要的作用，不过__type_traits就不是STL标准的东西了；前者负责处理萃取类型特性，后者负责萃取迭代器特性
__type_traits
__type_traits的意义主要是在构造和析构时决定急性怎么样的操作，主要是为了优化性能；比如对于int这样的类型来说，直接进行内存字节的操作即可，对于批量操作而言可以提升性能
__type_traits的定义
_STLP_TEMPLATE_NULL
struct __type_traits_aux<__false_type> {
typedef __false_type has_trivial_default_constructor;
typedef __false_type has_trivial_copy_constructor;
typedef __false_type has_trivial_assignment_operator;
typedef __false_type has_trivial_destructor;
typedef __false_type is_POD_type;
};
_STLP_TEMPLATE_NULL
struct __type_traits_aux<__true_type> {
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
template <class _Tp>
struct __type_traits {
typedef __true_type this_dummy_member_must_be_first;
typedef __false_type has_trivial_default_constructor; //构造函数是否有意义
typedef __false_type has_trivial_copy_constructor; //拷贝构造函数是否有意义
typedef __false_type has_trivial_assignment_operator; //赋值运算是否有意义
typedef __false_type has_trivial_destructor; //析构函数是否有意义
typedef __false_type is_POD_type; //是否是pod类型
};
在type_traits.h中提供了一个默认版本和两个特定类型模板的实现，is_POD_type和has_trivial_assignment_operator在STL空间配置器-构造析构中有进行说明，就以has_trivial_assignment_operator进行进一步的说明
has_trivial_assignment_operator
依旧以vector作为例子进行说明，在进行扩容操作时通过has_trivial_assignment_operator判断赋值运算是否有意义，对于原声的int类型之流的赋值运算是没有意义的，直接字节复制即可；不过即使赋值运算有意义，这里调用的也不会是赋值运算，因为这是扩容操作
-
插入元素时判断赋值运算是否有意义
void push_back(const _Tp& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) { if (this->_M_finish != this->_M_end_of_storage._M_data) { _Copy_Construct(this->_M_finish, __x); ++this->_M_finish; } else { //扩容时需要进行内容的复制，移动到新的地方 typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy; _M_insert_overflow(this->_M_finish, __x, _TrivialCopy(), 1, true); } } -
在赋值操作有意义的情况下不能直接进行字节操作了
void vector<_Tp, _Alloc>::_M_insert_overflow_aux(pointer __pos, const _Tp& __x, const __false_type& /*DO NOT USE!!*/, size_type __fill_len, bool __atend ) { typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy; //这里是和移动构造相关的，这里暂时不考虑这析，_Movable视为__false_type即可 #if !defined (_STLP_NO_MOVE_SEMANTIC) typedef typename __move_traits<_Tp>::implemented _Movable; #endif size_type __len = _M_compute_next_size(__fill_len); //分配空间 pointer __new_start = this->_M_end_of_storage.allocate(__len, __len); pointer __new_finish = __new_start; _STLP_TRY { //复制数据到新的内存中 __new_finish = _STLP_PRIV __uninitialized_move(this->_M_start, __pos, __new_start, _TrivialUCopy(), _Movable()); // ............. } template <class _InputIter, class _ForwardIter, class _TrivialUCpy> inline _ForwardIter __uninitialized_move(_InputIter __first, _InputIter __last, _ForwardIter __result, _TrivialUCpy __trivial_ucpy, const __false_type& /*_Movable*/) { return __ucopy_ptrs(__first, __last, __result, __trivial_ucpy); } -
拷贝构造函数没有意义的情况
template <class _InputIter, class _OutputIter> inline _OutputIter __ucopy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type& /*TrivialUCopy*/) { // we know they all pointers, so this cast is OK // return (_OutputIter)__copy_trivial(&(*__first), &(*__last), &(*__result)); return (_OutputIter)__ucopy_trivial(__first, __last, __result); } inline void* __ucopy_trivial(const void* __first, const void* __last, void* __result) { //dums: this version can use memcpy (__copy_trivial can't) return (__last == __first) ? __result : ((char*)memcpy(__result, __first, ((const char*)__last - (const char*)__first))) + ((const char*)__last - (const char*)__first); }在赋值运算没有意义的时候可以直接进行
memmove操作，因为通过内存复制操作就可以移动到新的位置来使用；在拷贝构造函数没有意义的时候可以直接进行memcpy操作，注意拷贝构造函数没有意义并不代表析构函数没有意义；赋值运算和拷贝构造的定义还是不一样的 -
拷贝构造函数有意义的情况
template <class _InputIter, class _OutputIter> inline _OutputIter __ucopy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type& /*TrivialUCopy*/) { return __ucopy(__first, __last, __result, random_access_iterator_tag(), (ptrdiff_t*)0); }在拷贝构造函数有意义的情况下需要对所有数据分别执行，但是这里有一个非常的问题就是怎么进行遍历操作，举个栗子
for (_Distance __n = __last - __first; __n > 0; --__n) { _Param_Construct(&*__cur, *__first); ++__first; ++__cur; }这是一种常用的遍历操作，但是
list类型就不支持这操作，这就涉及到iterator_traits操作了
偏特化
对于内置类型的特殊定义就是偏特化，内置类型的这些traits就会被定义为__true_type
# define _STLP_DEFINE_TYPE_TRAITS_FOR(Type) \
_STLP_TEMPLATE_NULL struct __type_traits< Type > : __type_traits_aux<__true_type> {}; \
_STLP_TEMPLATE_NULL struct __type_traits< const Type > : __type_traits_aux<__true_type> {}; \
_STLP_TEMPLATE_NULL struct __type_traits< volatile Type > : __type_traits_aux<__true_type> {}; \
_STLP_TEMPLATE_NULL struct __type_traits< const volatile Type > : __type_traits_aux<__true_type> {}
# ifndef _STLP_NO_BOOL
_STLP_DEFINE_TYPE_TRAITS_FOR(bool);
iterator_traits
迭代器萃取器的意义
- 迭代器主要是容器和算法的中间介质，
list和vector的迭代器支持的操作不一样，对于算法而言同样的算法内部的写法也可能不一样，需要区分出不同的迭代器类型 - 在进行查找操作时可能的需求就是最终返回迭代器的值，那就需要提供迭代器真正类型的定义；不是字符串，而是可以使用的符号定义
内嵌型别
c++中是没有运行时获取类型的方法的，唯一的方法就是typedef关键字，但是迭代器是模板类需要为不同的类型提供不同的定义；这就用到了模板类内嵌型别
#include <iostream>
using namespace std;
template<class T>
class TestA {
public:
typedef T value_type;
};
template<class T>
void func(T t) {
typename TestA<T>::value_type i = 1.3;
cout << i << endl;
}
int main() {
func(1.3);
return 0;
}
通过模板类加模板函数的方式就可以推导变量类型
iterator_traits
template <class _Iterator>
struct iterator_traits {
typedef typename _Iterator::iterator_category iterator_category; // 迭代器的类型
typedef typename _Iterator::value_type value_type; // 迭代器解引用后的类型
typedef typename _Iterator::difference_type difference_type; // 迭代器之间的距离
typedef typename _Iterator::pointer pointer; // 被迭代类型的原生指针的类型
typedef typename _Iterator::reference reference; // 被迭代类型的引用的类型
};
和__type_traits是具有很大不同的，类型迭代器中定义的通常是_false_type和_true_type在运行时通过不同的模板函数执行不同的动作，实际上执行的是if/else的判断操作；
template <class _Tp, class _Traits>
struct _Deque_iterator : public _Deque_iterator_base< _Tp> {
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef typename _Traits::reference reference;
typedef typename _Traits::pointer pointer;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef value_type** _Map_pointer;
以上就是deque的迭代器定义
偏特化处理
在这里会存在一个问题就是
vector提供的是原生指针迭代器，而原生指针是无法进行类似上面的操作的
template <class _Tp>
struct iterator_traits<_Tp*> {
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
STL中有为原生指针提供了针对指针的模板特殊实现
iterator_category
iterator_category就是用以规定一个迭代器支持的操作类型
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
一共提供了5种类型的定义
-
所有迭代器均支持如下操作
p++ 后置自增迭代器 ++p 前置自增迭代器 TYPE(iter) 拷贝构造所有迭代器均需要支持这两种操作
-
input_iterator_tag*p 解引用读取值 p->m 读取元素成员 p1==p2 比较迭代器的是否相等 p1!=p1 比较迭代器的是否不等 -
output_iterator_tag*p=val 解引用赋值 -
forward_iterator_tagstruct forward_iterator_tag : public input_iterator_tag {}; 继承于输入迭代器 p1=p2 迭代器赋值 -
bidirectional_iterator_tagstruct bidirectional_iterator_tag : public forward_iterator_tag {}; --p 前置自减迭代器 p-- 后置自减迭代器 -
random_access_iterator_tagstruct random_access_iterator_tag : public bidirectional_iterator_tag {}; p+=i 将迭代器递增i位 p-=i 将迭代器递减i位 p+i 在p位加i位后的迭代器 p-i 在p位减i位后的迭代器 p[i] 返回p位元素偏离i位的元素引用 p1<p2 如果迭代器p的位置在p1前，返回true，否则返回false p1<=p2 p的位置在p1的前面或同一位置时返回true，否则返回false p1>p2 如果迭代器p的位置在p1后，返回true，否则返回false p1>=p2 p的位置在p1的后面或同一位置时返回true，否则返回false p1-p2 返回迭代器之间的距离
vector/list的迭代器类型定义
-
vector提供的就是原声指针，为random_access_iterator_tag类型，在偏特化中定义template <class _Tp> struct iterator_traits<_Tp*> { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef _Tp& reference; }; -
list提供的时bidirectional_iterator_tag，允许前后移动但不允许跳动struct _List_iterator_base { typedef size_t size_type; typedef ptrdiff_t difference_type; typedef bidirectional_iterator_tag iterator_category; _List_node_base* _M_node; _List_iterator_base(_List_node_base* __x) : _M_node(__x) {} void _M_incr() { _M_node = _M_node->_M_next; } void _M_decr() { _M_node = _M_node->_M_prev; } };
均符合偏特化的定义
uninitialized_copy的实现
_InputIter类型的复制函数
template <class _InputIter, class _OutputIter, class _Distance>
inline _OutputIter __ucopy(_InputIter __first, _InputIter __last,
_OutputIter __result, _Distance*) {
_OutputIter __cur = __result;
_STLP_TRY {
for ( ; __first != __last; ++__first, ++__cur)
_Param_Construct(&*__cur, *__first);
return __cur;
}
_STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __cur))
_STLP_RET_AFTER_THROW(__cur)
}
只能通过++运算符移动
_RandomAccessIter的实现
template <class _RandomAccessIter, class _OutputIter, class _Distance>
inline _OutputIter __ucopy(_RandomAccessIter __first, _RandomAccessIter __last,
_OutputIter __result, const random_access_iterator_tag &, _Distance*) {
_OutputIter __cur = __result;
_STLP_TRY {
for (_Distance __n = __last - __first; __n > 0; --__n) {
_Param_Construct(&*__cur, *__first);
++__first;
++__cur;
}
return __cur;
}
_STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __cur))
_STLP_RET_AFTER_THROW(__cur)
}
可以通过减法来计算距离
网友评论