c++标准模板（STL），std::array用法说明

定义于头文件 <array>
template<     class T,     std::size_t N > struct array;		(C++11 起)

std::array 是封装固定大小数组的容器。

此容器是一个聚合类型，其语义等同于保有一个 C 风格数组 T[N] 作为其唯一非静态数据成员的结构体。不同于 C 风格数组，它不会自动退化成 T* 。它能作为聚合类型聚合初始化，只要有至多 N 个能转换成 T 的初始化器： std::array<int, 3> a = {1,2,3}; 。

该结构体结合了 C 风格数组的性能、可访问性与容器的优点，比如可获取大小、支持赋值、随机访问迭代器等。

std::array 满足容器 (Container) 和可逆容器 (ReversibleContainer) 的要求，除了默认构造的 array 是非空的，以及进行交换的复杂度是线性，它满足连续容器 (ContiguousContainer) (C++17 起)的要求并部分满足序列容器 (SequenceContainer) 的要求。

当其长度为零时 array （ N == 0 ）有特殊情况。此时， array.begin() == array.end() ，并拥有某个唯一值。在零长 array 上调用 front() 或 back() 是未定义的。

亦可将 array 当做拥有 N 个同类型元素的元组。

迭代器非法化

按照规则，指向 array 的迭代器在 array 的生存期间决不非法化。然而要注意，在 swap 时，迭代器将继续指向同一 array 的元素，并将改变元素的值。

成员类型

成员类型	定义
value_type	T
size_type	std::size_t
difference_type	std::ptrdiff_t
reference	value_type&
const_reference	const value_type&
pointer	value_type*
const_pointer	const value_type*
iterator	遗留随机访问迭代器 (LegacyRandomAccessIterator) 兼常量表达式迭代器 (ConstexprIterator) (C++20 起)且为字面类型 (LiteralType) (C++17 起)
const_iterator	常随机访问迭代器兼常量表达式迭代器 (ConstexprIterator) (C++20 起)且为字面类型 (LiteralType) (C++17 起)
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

成员函数

隐式定义的成员函数
(构造函数) (隐式声明)	遵循聚合初始化的规则初始化 array （注意默认初始化可以导致非类的 T 的不确定值） (公开成员函数)
(析构函数) (隐式声明)	销毁 array 的每个元素 (公开成员函数)
operator= (隐式声明)	以来自另一 array 的每个元素重写 array 的对应元素 (公开成员函数)
元素访问
at	访问指定的元素，同时进行越界检查 (公开成员函数)
operator[]	访问指定的元素 (公开成员函数)
front	访问第一个元素 (公开成员函数)
back	访问最后一个元素 (公开成员函数)
data	返回指向内存中数组第一个元素的指针 (公开成员函数)
迭代器
begin cbegin	返回指向容器第一个元素的迭代器 (公开成员函数)
end cend	返回指向容器尾端的迭代器 (公开成员函数)
rbegin crbegin	返回指向容器最后元素的逆向迭代器 (公开成员函数)
rend crend	返回指向前端的逆向迭代器 (公开成员函数)
容量
empty	检查容器是否为空 (公开成员函数)
size	返回容纳的元素数 (公开成员函数)
max_size	返回可容纳的最大元素数 (公开成员函数)
操作
fill	以指定值填充容器 (公开成员函数)
swap	交换内容 (公开成员函数)

非成员函数

operator==operator!=operator<operator<=operator>operator>=	按照字典顺序比较 array 中的值 (函数模板)
std::get(std::array)	访问 array 的一个元素 (函数模板)
std::swap(std::array) (C++11)	特化 std::swap 算法 (函数模板)
to_array (C++20)	从内建数组创建 std::array 对象 (函数模板)

辅助类

std::tuple_size<std::array>	获得 array 的大小 (类模板特化)
std::tuple_element<std::array>	获得 array 元素的类型 (类模板特化)

代码示例

#include <string>
#include <iostream>
#include <algorithm>
#include <array>
#include <iterator>

int main()
{
    // 用聚合初始化构造
    std::array<int, 5> a1{ {1, 2, 3, 4, 5} };   // CWG 1270 重申前的 C++11 中要求双花括号
                                                // （ C++11 之后的版本和 C++14 起不要求）
    std::array<int, 5> a2 = {1, 2, 3};          // = 后决不要求

    //从0开始，访问指定的元素，同时进行越界检查，越界时抛出异常
    std::cout << "a1.at(1): " << a1.at(1) << std::endl; // 打印   2

    //从0开始，访问指定的元素，不进行越界检查
    std::cout << "a1[10]:   " << a1[10] << std::endl;   // 未知，打印结果因系统而异

    std::cout << "------------\n";

    //访问第一个元素
    std::cout << "front():  " << a1.front() << std::endl;   // // 打印   1

    //访问最后一个元素
    std::cout << "back():  " << a1.back() << std::endl;   // // 打印   5

    std::cout << "------------\n";
    //iterator  迭代器
    //const_iterator 只读迭代器      const：只读
    // 打印   1 2 3 4 5
    std::cout << "order:  ";
    for(std::array<int, 5>::const_iterator it = a1.begin(); it != a1.end(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << "\n";

    // 打印 5 4 3 2 1
    std::cout << "reverse:  ";
    for(std::array<int, 5>::const_reverse_iterator it = a1.rbegin(); it != a1.rend(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << "\n";

    std::cout << "------------\n";

    // 检查容器是否为空
    std::cout << "empty(): " << a1.empty() << "\n"; // 打印 0

    // 返回容纳的元素数
    std::cout << "size(): " << a1.size() << "\n"; // 打印 5
    // 返回容纳的元素数, 在array中 size(),max_size()查看源码,表示的都是数组大小，一致
    std::cout << "max_size(): " << a1.max_size() << "\n"; // 打印 5

    std::cout << "------------\n";
    // 赋给定值 value 给容器中的所有元素。
    a2.fill(3);
    std::cout << "fill(): ";
    // 支持带范围 for 循环
    // 打印 3 3 3 3 3
    for(const auto& s: a2)
        std::cout << s << ' ';
    std::cout << "\n";
    std::cout << "------------\n";

    //交换内容,将容器内容与 other 的内容交换。不导致迭代器和引用关联到别的容器,
    //长度一致
    a1.swap(a2);
    std::cout << "swap():\n";
    for(const auto& s: a1)
        std::cout << s << ' ';
    std::cout << "\n";
    for(const auto& s: a2)
        std::cout << s << ' ';
    std::cout << "\n";

    std::cout << "------------\n";
    // 访问 array 的一个元素
    //从 array 提取第 Ith 个元素。
    //I 必须是范围 [0, N) 中的整数值。与 at() 或 operator[] 相反，这在编译时强制。
    std::get<0>(a1) = 1;
    // 打印 a[0] = 1
    std::cout << "get(): a[0]   " << a1[0] << std::endl;
    std::cout << "------------\n";

    // 排序
    std::cout << "sort():\n";
    for(const auto& s: a2)
        std::cout << s << ' ';
    std::cout << "\n";

    // 大到小
    std::cout << "std::greater: ";
    std::sort(a2.begin(), a2.end(), std::greater<int>());
    for(const auto& s: a2)
        std::cout << s << ' ';
    std::cout << "\n";
    // 小到大
    std::cout << "std::less: ";
    std::sort(a2.begin(), a2.end(), std::less<int>());
    for(const auto& s: a2)
        std::cout << s << ' ';
    std::cout << "\n";
    std::cout << "------------\n";

    // 逆序拷贝
    std::cout << "reverse_copy(): ";
    std::reverse_copy(a2.begin(), a2.end(),
                      std::ostream_iterator<int>(std::cout, " "));

    std::cout << '\n';
}