C++ STL源码剖析 tr1与std array

0.导语

源码剖析版本为gcc4.9.1。

C++ tr1全称Technical Report 1，是针对C++标准库的第一次扩展。即将到来的下一个版本的C++标准c++0x会包括它，以及一些语言本身的扩充。tr1包括大家期待已久的smart pointer，正则表达式以及其他一些支持范型编程的内容。草案阶段，新增的类和模板的名字空间是std::tr1。

1.std::tr1::array

使用：

  1. #include <tr1/array>
  2. std::tr1::array<int ,10> a;

tr1中的array比较简单，模拟语言本身的数组，并且让其支持迭代器操作，使其同其他容器一样，能够调用算法。对于tr1中array没有构造与析构。迭代器是直接使用传递进来的类型定义指针。

简单的看一下这个静态数组array源码：

  1. template<typename _Tp, std::size_t _Nm>
  2. struct array
  3. {
  4.     typedef _Tp                           value_type;
  5.     typedef value_type&                           reference;
  6.     typedef const value_type&                     const_reference;
  7.     typedef value_type*                       iterator;
  8.     typedef const value_type*                 const_iterator;
  9.     typedef std::size_t                           size_type;
  10.     typedef std::ptrdiff_t                         difference_type;
  11.     typedef std::reverse_iterator<iterator>       reverse_iterator;
  12.     typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
  13. }

里面使用reverse_iterator作为rbegin与rend操作的迭代器。看上去上面一个迭代器，实际上两个，还有一个iterator,这个直接使用传递进来的类型定义指针，作为迭代器。

可以将其对比为vector中的正向与反向迭代器。

值得注意的是，在tr1::array中，支持传递数组大小为0，例如我们使用如下：

  1. std::tr1::array<int,0> a;

对于这样的写法，会对应到下面：

  1. // Support for zero-sized arrays mandatory.
  2. value_type _M_instance[_Nm ? _Nm : 1];

根据传递进来的大小，如果不为0，就是传递进来的大小，否则为1。

2.std::array

使用

  1. std::array<int ,10> a;

std中的array包含了

std_array.png

对比tr1与std的array

  1. template<typename _Tp, std::size_t _Nm>
  2. struct array
  3. {
  4.     typedef _Tp                           value_type;
  5.     typedef value_type*               pointer;
  6.     typedef const value_type*                       const_pointer;
  7.     typedef value_type&                           reference;
  8.     typedef const value_type&                     const_reference;
  9.     typedef value_type*                       iterator;
  10.     typedef const value_type*                 const_iterator;
  11.     typedef std::size_t                           size_type;
  12.     typedef std::ptrdiff_t                            difference_type;
  13.     typedef std::reverse_iterator<iterator>       reverse_iterator;
  14.     typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
  16.     // Support for zero-sized arrays mandatory.
  17.     typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;    // # define _GLIBCXX_STD_C std
  18.     typename _AT_Type::_Type                         _M_elems;
  19. }

发现array里面有两处值得注意的地方：

  1. // Support for zero-sized arrays mandatory.
  2. typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;    // # define _GLIBCXX_STD_C std
  3. typename _AT_Type::_Type                         _M_elems;

在源码中去找__array_traits，看到：

  1. template<typename _Tp, std::size_t _Nm>
  2. struct __array_traits
  3. {
  4.     typedef _Tp _Type[_Nm];
  6.     static constexpr _Tp&
  7.     _S_ref(const _Type& __t, std::size_t __n) noexcept
  8.     { return const_cast<_Tp&>(__t[__n]); }
  9. };

上面两行的代码可以理解为下面：

  1. typedef _Tp _Type[100];
  2. typedef _Type _M_elems;  // 一个含有100个元素的数组。

在实际写代码的时候，如果要定义一个数组，我们可以这样写：

  1. int a[100];
  2. //或者
  3. typedef int T[100];
  4. typedef T a;

针对传进来的size处理，相比于tr1，更加复杂，使用了模板偏特化来处理传递size为0情况。

  1. template<typename _Tp, std::size_t _Nm>
  2. struct __array_traits
  3. {
  4.     typedef _Tp _Type[_Nm];
  6.     static constexpr _Tp&
  7.     _S_ref(const _Type& __t, std::size_t __n) noexcept
  8.     { return const_cast<_Tp&>(__t[__n]); }
  9. };
  11. template<typename _Tp>
  12. struct __array_traits<_Tp, 0>
  13. {
  14.     struct _Type { };
  16.     static constexpr _Tp&
  17.     _S_ref(const _Type&, std::size_t) noexcept
  18.     { return *static_cast<_Tp*>(nullptr); }
  19. };