std::array
std::array是c-style数组的对象化包装。我们知道c-style数组在使用时很痛苦的一点是数组本身并不知道自己有多少个元素，所以我们不得不花很大的精力确保数组不会越界。而std::array克服了这一缺陷，它自带size信息，这使得它使用起来很方便，我们来看几个例子：
#include <string>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <array>
int main(){
// construction uses aggregate initialization
std::array<int, 3> a1{ {1, 2, 3} }; // double-braces required in C++11 (not in C++14)
std::array<int, 3> a2 = {1, 2, 3}; // never required after =
std::array<std::string, 2> a3 = { std::string("a"), "b" };
// container operations are supported
std::sort(a1.begin(), a1.end());
std::reverse_copy(a2.begin(), a2.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
// ranged for loop is supported
for(const auto& s: a3)
std::cout << s << ' ';
}
输出：
3 2 1
a b
std::array源代码分析
相较于很多类——比如tuple、bind等——那如天书一般的源代码，std::array的源代码算是真正的良心之作，几乎不需要什么智商就能看明白：
template<class _Tp, size_t _Size>
struct array {
// types:
typedef array __self;
typedef _Tp value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// 唯一的成员，c-style数组
value_type __elems_[_Size > 0 ? _Size : 1];
// ...
看到了吧，刨去那一大堆的typedef，std::array就只有一个成员：__elems_，这是一个c-style的数组std::array就是就是C原生数组的一个马甲而已。
当然，这个马甲有个很好的特性：自带size信息：
template<class _Tp, size_t _Size>
struct array {
// ...
// capacity:
inline constexpr size_type size() const noexcept {return _Size;}
inline constexpr bool empty() const noexcept {return _Size == 0;}
// ...
};
另外，这个穿上马甲的std::array已经摇身一变成了一个容器，既然是容器，就必须遵循C++标准可以关于容器的concept，比如遍历，获取元素等等：
template<class _Tp, size_t _Size>
struct array {
// ...
// iterators:
inline constexpr iterator begin() noexcept {return iterator(__elems_);}
inline constexpr iterator end() noexcept {return iterator(__elems_ + _Size);}
// ...
// element access:
inline constexpr reference operator[](size_type __n) {return __elems_[__n];}
constexpr reference at(size_type __n) {
if (__n >= _Size) __throw_out_of_range("array:at");
return __elems_[__n];
}
// ...
};
源代码确实很简单，就不多讲了。最后再说点题外话：swap，我们来看看std::array是怎样实现swap的：
template <class _Tp, size_t _Size>
struct array{
// ...
inline void swap(array& __a) noexcept(_Size == 0 || __is_nothrow_swappable<_Tp>::value) {
__swap_dispatch((std::integral_constant<bool, _Size == 0>()), __a);
}
inline void __swap_dispatch(std::true_type, array&){}
inline void __swap_dispatch(std::false_type, array& __a) {
std::swap_range(__elems_, __elems_ + _Size, __a.__elems_);
}
};
template<class _Tp, size_t _Size>
inline
typename enable_if<_Size == 0 || __is_swappable<_Tp>::value, void>::type
swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y) {
__x.swap(__y);
}
