c++拓展-4:序列式容器STL array

array<T,N>（数组容器）

简要说明及其定义

在c++的普通数组上新增了一些成员函数和全局函数的容器，使用时需要调用对应的< array >头文件，示意如下图：

在array<T,N>类模板中，T用于指明数据类型，N表示数据个数，一旦建立则长度固定不变，即不能增加和删除，只能改变某个元素的值，故N也必须是常量，不可以用变量表示

如下语句为创建一个具有5个char类型元素的array容器，其名为value，{}负责初始化（没有初始化可省略），未被初始化的值将默认设为0

std::array<char,5> values{'a','b','c'};

由于array的类模板位于命名空间std，所以当默认空间为std时，前面表示作用域的std::可以省略

容器提供的成员函数

头文件< array >中不仅封装了array容器的定义，也提供了可供使用的成员函数，调用成员函数的时候可以直接通过类的方式调用，即：array容器的名称.成员函数（）

【此处有关迭代器的成员函数被后置到下一个小标题，可通过目录跳转查看】

成员函数	功能
size()	返回容器中当前元素的数量，其值始终等于初始化 array 类的第二个模板参数 N。
max_size()	返回容器可容纳元素的最大数量，其值始终等于初始化 array 类的第二个模板参数 N。
empty()	判断容器是否为空，和通过 size()==0 的判断条件功能相同，但其效率可能更快。
at(n)	返回容器中 n 位置处元素的引用，该函数自动检查 n 是否在有效的范围内，如果不是则抛出 out_of_range 异常。
front()	返回容器中第一个元素的直接引用，该函数不适用于空的 array 容器。
back()	返回容器中最后一个元素的直接应用，该函数同样不适用于空的 array 容器。
data()	返回一个指向容器首个元素的指针。利用该指针，可实现复制容器中所有元素等类似功能。
fill(val)	将 val 这个值赋值给容器中的每个元素。
array1.swap(array2)	交换 array1 和 array2 容器中的所有元素，但前提是它们具有相同的长度和类型。

此外，get（）全局函数也被array头文件重载，该重载函数的功能是访问容器中指定元素并返回该元素的引用

array容器迭代器

array容器配备的迭代器是功能最为强大的随机访问迭代器

成员函数	功能
begin()	返回指向容器中第一个元素的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。
end()	返回指向容器最后一个元素之后一个位置的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。此函数通常和 begin() 搭配使用。
rbegin()	返回指向最后一个元素的反向迭代器；如果是 const 类型容器，在该函数返回的是常量反向迭代器。
rend()	返回指向第一个元素之前一个位置的反向迭代器。如果是 const 类型容器，在该函数返回的是常量反向迭代器。此函数通常和 rbegin() 搭配使用。
cbegin()	和 begin() 功能类似，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。
cend()	和 end() 功能相同，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。
crbegin()	和 rbegin() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。
crend()	和 rend() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。

注：代码中的auto关键字可以使编译器自动判定变量的类型，并完成该类型变量的定义，以上函数在实际使用时，都可以用auto代替其返回值类型，编译器可以自行判断出该迭代器的类型

begin（）/end（）和cbegin（）/cend（）

begin()和end()返回正向迭代器对象，分别指向“首元素”和“尾元素+1”的位置，在实际使用中，可以利用其完成初始化容器和遍历容器中元素

由于c++11的全局中begin（）和end（）函数也能够从容器中获取迭代器，且当操作对象是array时，能够与封装的函数通用，故而以下两者是等价的：

auto first = values.begin();	//用封装的函数begin（）定义
auto first = std::begin(values);	//用全局函数begin（）定义

cbegin（）/cend（）返回的是const类型的正向迭代器，可以用于遍历容器中元素，可以访问元素，但无法修改所存储的元素，这一点和c++中被const关键字控制的数据和函数都无法进行元素修改

rbegin（）/rend（）和crbegin（）/crend（）

rbegin（）/rend（）可以分别返回指向最后一个元素和指向第一个元素前一个位置的随机访问迭代器，又称反向迭代器，用于逆序的方式处理元素。

注：在使用反向迭代器进行++和–运算的时候，++指的是迭代器向左移动一位，–指的是迭代器向右移动一位，即和正向时相比，两个运算符的功能也互换了

而crbegin（）和crend（）和上述的唯一差别也在于返回的迭代器为const类型，不能用于修改容器中的元素，除此之外，使用上和上述完全相同

访问array容器

单个元素

首先，可以通过**容器名[]**的方式直接访问和使用容器中的元素，和普通数组访问元素的方式相同，例如：

values[4] = values[3] + 2*values[1];

此行代码中，第 5 个元素的值被赋值为右边表达式的值。需要注意的是，使用如上这样方式，由于没有做任何边界检查，所以即便使用越界的索引值去访问或存储元素，也不会被检测到。

为了能够有效地避免越界访问的情况，可以使用 array 容器提供的 at() 成员函数，例如 :

values.at (4) = values.at(3) + 2*values.at(1);

这行代码和前一行语句相比，当发生越界时，程序会抛出out_of_range异常，所以除非确定没有越界，否则at（）比直接引用会更加安全

当然，如果每次访问元素都去检查是否越界的话，无疑会产生很多性能开销，当不可能越界时，还是避免为好

array 容器还提供了 get< n > 模板函数，它是一个辅助函数，能够获取到容器的第 n 个元素，但是其中n只能是一个常量表达式，不可以是循环变量

array的成员函数中还有着data（）函数，该函数返回一个指向元素的指针，可以使用【*（a+i）】的方式访问容器中各个元素的值

多个元素

可以利用size（）函数【返回值为size_t】作为循环条件访问：

double total = 0;
for(size_t i = 0 ; i < values.size() ; ++i)
{
    total += values[i];
}

此外，对于任何可以使用迭代器的容器都可以使用基于范围的循环：

double total = 0;
for(auto&& value : values)
    total += value;

注：for(auto &c:s)是在c11标准下可以执行的特殊格式的for循环语句，区别在于引用类型可以改变原来的值，可以对容器中的内容进行赋值，即可通过对c赋值来做到容器s的填充，在不加“&”引用符号时，可以利用c遍历并获得s容器中的每个值，但c无法改变s容器中的元素

总结

• 定义方式
• 迭代器函数
• 访问元素

array<数据类型，数据个数（常数）> 数组名{可省略的初始化列表}；

• begin（）/end（）：返回“开头/结尾+1”处的元素的正向迭代器

• 前加r：返回“开头-1/结尾”的反向迭代器——rbegin（）/rend（）

• 前加c：返回const类型的元素迭代器——cbegin()/cend(),crbegin()/crend()

对于单个元素：

• 用容器名[i]的方式——直接访问，性能最高
• 使用at()函数——可避免越界
• 使用get< n >对固定位置的元素访问——n只能使用常量
• 使用data()函数获得指向第一个元素的指针——用*（a+i）读取第i个元素

对于多个元素：

• 使用size（）函数作为条件循环获取
• 使用for（auto &c:s）这一特殊格式的for循环完成遍历赋值，只读时不加“&”引用符

代码实例

#include <iostream>	//需要引入 array 头文件
#include <array>
using namespace std;
int main()
{
    std::array<int, 4> values{};	//初始化 values 容器为 {0,1,2,3}
    for (int i = 0; i < values.size(); i++) {
        values.at(i) = i;	//使用 get() 重载函数输出指定位置元素
    }
    cout << get<3>(values) << endl;	//如果容器不为空，则输出容器中所有的元素
    if (!values.empty()) {
        for (auto val = values.begin(); val < values.end(); val++) {
            cout << *val << " ";
        }
    }
}

输出结果为：

3
0 1 2 3

#include <iostream>
#include <iomanip> 
#include <array>
using namespace std;
int main()
{
    array<int, 5> values1;
    array<int, 5> values2;
    //初始化 values1 为 {0,1,2,3,4}
    for (size_t i = 0; i < values1.size(); ++i)
    {
        values1.at(i) = i;
    }
    cout << "values1[0] is : " << values1[0] << endl;
    cout << "values1[1] is : " << values1.at(1) << endl;
    cout << "values1[2] is : " << get<2>(values1) << endl;
    //初始化 values2 为{10，11，12，13，14}
    int initvalue = 10;
    for (auto& value : values2)
    {
        value = initvalue;
        initvalue++;
    }
    cout <<  "Values1 is : ";
    for (auto i = values1.begin(); i < values1.end(); i++) {
        cout << *i << " ";
    }
    cout << endl << "Values2 is : ";
    for (auto i = values2.begin(); i < values2.end(); i++) {
        cout << *i << " ";
    }
    return 0;
}

输出结果为：

values1[0] is : 0
values1[1] is : 1
values1[2] is : 2
Values1 is : 0 1 2 3 4
Values2 is : 10 11 12 13 14

题外话：由于STL标准库不是只有array容器，当迭代器指向容器中一个特定元素时，迭代器不会保留任何关于容器本身的信息，所以我们无法从迭代器中判断，迭代器到底指向array容器还是vector容器

（即：只知道一个数据的类型和存储它的地址，无法判断这一整组数据是静态数组还是动态数组）