std::array

template < class T, size_t N > class array;

说明：

​ 数组是固定大小的序列容器:它们以严格的线性序列保存特定数量的元素。在内部，数组不需要保留它所包含的元素以外的任何数据。这个类只添加了一层成员和全局函数，这样数组就可以用作标准容器。与其他容器不同的是，它固定大小，不通过allocator来管理元素的分类；它是封装了固定大小的元素数组的聚合类型。不能动态扩展或收缩。

• 零大小的array是有效的，但不能对其任何iterator解引用。
• 另一个特殊的地方是它们可以被视为元组对象，头重载get函数，以访问数组的元素。

性质：

1. 序列，即容器中的元素按严格的线性顺序排列。
2. 内存连续，可以随机访问每一个元素，也可以通过指针偏移量来访问。
3. 固定大小。

模板参数：

• T:元素的类型。
• N:数组元素个数。

成员类型：

​ 以下别名是数组的成员类型。它们被广泛使用在成员函数的形参和返回类型。

成员函数：

​ 1. iterator

2. capacity

   function	commit
   size	返回数组容量的大小，即模板参数中的第二个参数值
   max_size	返回数组容器所能容纳的最大元素数，其实和size作用相同
   empty	判断数组是否为空，即size = 0

3. element access

   function
   operator[]	通过下标位置访问数组中元素，返回元素的引用
   at	通过index位置访问数组中元素，返回元素引用
   front	返回数组中首元素的引用
   back	返回数组中最后一个元素的引用
   data	返回指向数组对象首元素的指针

4. modifiers

   function
   void fill (const value_type& val);	将数组中所有元素值设为val
   void swap (array& x) noexcept

5. 非成员函数

   function
   get(array)	返回某个位置元素的引用
   relational operators	数组还重载了一系列的关系运算符

   //I:数组中元素的位置 T:元素类型 N:元素个数
   template <size_t I, class T, size_t N> T& get (array<T,N>& arr) noexcept;
   template <size_t I, class T, size_t N> T&& get (array<T,N>&& arr) noexcept;
   template <size_t I, class T, size_t N> const T& get (const array<T,N>& arr) noexcept;
   

   //重载的关系运算符
   template <class T, size_T N>
     bool operator== ( const array<T,N>& lhs, const array<T,N>& rhs );
   
   template <class T, size_T N>
     bool operator!= ( const array<T,N>& lhs, const array<T,N>& rhs );
   	
   template <class T, size_T N>
     bool operator<  ( const array<T,N>& lhs, const array<T,N>& rhs );
   	
   template <class T, size_T N>
     bool operator<= ( const array<T,N>& lhs, const array<T,N>& rhs );
   	
   template <class T, size_T N>
     bool operator>  ( const array<T,N>& lhs, const array<T,N>& rhs );
   	
   template <class T, size_T N>
     bool operator>= ( const array<T,N>& lhs, const array<T,N>& rhs );
   

6. 非成员类专门化函数

   • std::tuple_element

     //像访问元组一样访问数组对象中元素的静态类型。
     template <size_t I, class Tpl> class tuple_element;   // unspecialized
     template <size_t I, class T, size_t N>
       struct tuple_element <I, array<T,N>>;               // array specialization
     

   • std::tuple_size

     //像访问元组一样访问数组对象的大小
     template <class Tpl> class tuple_size;     // unspecialized
     template <class T, size_t N>
       struct tuple_size< array<T,N> >;         // array specialization
     

测试代码：

#include <iostream>
#include <array>
#include <algorithm>
#include <string>
using namespace std;

int main()
{
	array<int, 10> _array;
	//assign value to all elements
	_array.fill(1);
	//return iterator
	for_each(_array.begin(), _array.end(), [](int val) {std::cout << val << " "; });
	cout << endl;
	array<int, 10> _array_1;
	_array_1.fill(0);
	//swap two array
	_array_1.swap(_array);
	for_each(_array.begin(), _array.end(), [](int val) {std::cout << val << " "; });
	cout << endl;

	array<string, 5> strArray;
	//same fill
	strArray.assign("hello");
	for_each(strArray.begin(), strArray.end(), [](string val) {std::cout << val << " "; });
	cout << endl;
		//return current element numbers
	cout << strArray.size() << " " << strArray.max_size();
	strArray[0] = "Rafiki";
	strArray[1] = "world";
	for_each(strArray.begin(), strArray.end(), [](string val) {std::cout << val << " "; });
	cout << endl;

	//返回数组中首尾元素的引用
	string& front = strArray.front();
	string& back = strArray.back();
	cout << "front value:" << front << " back value:" << back << endl;
	//return pointer to nonmutable data array
	strArray.data();
	return 0;
}