array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全，且效率并没有因此变差。和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。
C++ 11 标准库还新增加了 begin() 和 end() 这 2 个函数，和 array 容器包含的 begin() 和 end() 成员函数不同的是，标准库提供的这 2 个函数的操作对象，既可以是容器，还可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；如果操作对象是普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针（注意不是最后一个元素）。另外，在 <array> 头文件中还重载了 get() 全局函数，该重载函数的功能是访问容器中指定的元素，并返回该元素的引用。
正是由于 array 容器中包含了 at() 这样的成员函数，使得操作元素时比普通数组更安全。
本文作者原创，转载请附上文章出处与本文链接。
C++ STL array 容器(深入了解,一文学会)目录
| 成员函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的随机访问迭代器。 |
| end() | 返回指向容器最后一个元素之后一个位置的随机访问迭代器，通常和 begin() 结合使用。 |
| rbegin() | 返回指向最后一个元素的随机访问迭代器。 |
| rend() | 返回指向第一个元素之前一个位置的随机访问迭代器。 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上增加了 const 属性，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| 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 容器中的所有元素，但前提是它们具有相同的长度和类型。 |
.h
#include <array>
using namespace std;
.cpp
//创建具有 10 个 double 类型元素的 array 容器
array<double, 10> values;
//对元素进行初始化
array<double, 10> values {0.5,1.0,1.5,,2.0}; array<int, 4> values{};
//初始化 values 容器为 {0,1,2,3}
for (int i = 0; i < values.size(); i++) {
values.at(i) = i;
}
//使用 get() 重载函数输出指定位置元素
//get<3>(values) //3
//如果容器不为空，则输出容器中所有的元素
if (!values.empty()) {
for (auto val = values.begin(); val < values.end(); val++) {
cout << *val << " ";
}
}
//0 1 2 3| 成员函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。 |
| end() | 返回指向容器最后一个元素之后一个位置的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。此函数通常和 begin() 搭配使用。 |
| rbegin() | 返回指向最后一个元素的反向迭代器；如果是 const 类型容器，在该函数返回的是常量反向迭代器。 |
| rend() | 返回指向第一个元素之前一个位置的反向迭代器。如果是 const 类型容器，在该函数返回的是常量反向迭代器。此函数通常和 rbegin() 搭配使用。 |
| cbegin() | 和 begin() 功能类似，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
C++ 11 标准新增的 begin() 和 end() 函数，当操作对象为 array 容器时，也和迭代器有关，其功能分别和下图中的 begin()、end() 成员函数相同
根据它们的功能并结合实际场景的需要，这些成员函数通常是成对使用的，即 begin()/end()、rbegin()/rend()、cbegin()/cend()、crbegin()/crend() 各自成对搭配使用。不仅如此，这 4 对中 begin()/end() 和 cbegin()/cend()、rbegin()/rend() 和 crbegin()/crend() 的功能大致是相同的（如上图所示），唯一的区别就在于其返回的迭代器能否用来修改元素值。
值得一提的是，以上函数在实际使用时，其返回值类型都可以使用 auto 关键字代替，编译器可以自行判断出该迭代器的类型。
array 容器模板类中的 begin() 和 end() 成员函数返回的都是正向迭代器，它们分别指向「首元素」和「尾元素+1」 的位置。在实际使用时，我们可以利用它们实现初始化容器或者遍历容器中元素的操作。可以在循环中显式地使用迭代器来初始化 values 容器的值
array<int, 5>values;
int h = 1;
auto first = values.begin();
auto last = values.end();
//初始化 values 容器为{1,2,3,4,5}
while (first != last)
{
*first = h;
++first;
h++;
}
//正向迭代
first = values.begin();
while (first != last)
{
cout << *first << " ";
++first;
}
//1 2 3 4 5可以看出，迭代器对象是由 array 对象的成员函数 begin() 和 end() 返回的。我们可以像使用普通指针那样上使用迭代器对象。比如代码中，在保存了元素值后，使用前缀 ++ 运算符对 first 进行自增，当 first 等于 end 时，所有的元素都被设完值，循环结束。与此同时，还可以使用全局的 begin() 和 end() 函数来从容器中获取迭代器，因为当操作对象为 array 容器时，它们和 begin()/end() 成员函数是通用的。所以上面代码中，first 和 last 还可以像下面这样定义：
auto first = std::begin(values);
auto last = std::end (values);array 模板类还提供了 cbegin() 和 cend() 成员函数，它们和 begin()/end() 唯一不同的是，前者返回的是 const 类型的正向迭代器，这就意味着，有 cbegin() 和 cend() 成员函数返回的迭代器，可以用来遍历容器内的元素，也可以访问元素，但是不能对所存储的元素进行修改。
array<int, 5>values{ 1,2,3,4,5 };
int h = 1;
auto first = values.cbegin();
auto last = values.cend();
//由于 *first 为 const 类型，不能用来修改元素
//*first = 10;
//遍历容器并输出容器中所有元素
while (first != last)
{
//可以使用 const 类型迭代器访问元素
cout << *first << " ";
++first;
}
//1 2 3 4 5此程序的*first = 10中，我们尝试使用 first 迭代器修改 values 容器中的值，如果取消注释并运行此程序，编译器会提示你“不能给常量赋值”，即 *first 是 const 类型常量，所以这么做是不对的。但是遍历并访问容器的行为，是允许的。
array 模板类中还提供了 rbegin()/rend() 和 crbegin()/crend() 成员函数，它们每对都可以分别得到指向最一个元素和第一个元素前一个位置的随机访问迭代器，又称它们为反向迭代器。
需要注意的是，在使用反向迭代器进行 ++ 或 -- 运算时，++ 指的是迭代器向左移动一位，-- 指的是迭代器向右移动一位，即这两个运算符的功能也“互换”了。
array<int, 5>values;
int h = 1;
auto first = values.rbegin();
auto last = values.rend();
//初始化 values 容器为 {5,4,3,2,1} //rbegin 反向插入
while (first != last)
{
*first = h;
++first;
h++;
}
//重新遍历容器，并输入各个元素
first = values.rbegin();
while (first != last)
{
cout << *first << " ";
++first;
}
/*
for (auto first = values.rbegin(); first != values.rend(); ++first) {
cout << *first << " ";
}
*/
//1 2 3 4 5可以看到，从最后一个元素开始循环，不仅完成了容器的初始化，还遍历输出了容器中的所有元素。结束迭代器指向第一个元素之前的位置，所以当 first 指向第一个元素并 +1 后，循环就结朿了。
在反向迭代器上使用 ++ 递增运算符，会让迭代器用一种和普通正向迭代器移动方向相反的方式移动。
crbegin()/crend() 组合和 rbegin()/crend() 组合的功能唯一的区别在于，前者返回的迭代器为 const 类型，即不能用来修改容器中的元素，除此之外在使用上和后者完全相同。
可以通过容器名[]的方式直接访问和使用容器中的元素，这和普通数组访问元素的方式相同
values[4] = values[3] + 2.O*values[1];此行代码中，第 5 个元素的值被赋值为右边表达式的值。需要注意的是，使用如上这样方式，由于没有做任何边界检查，所以即便使用越界的索引值去访问或存储元素，也不会被检测到。
为了能够有效地避免越界访问的情况，可以使用 array 容器提供的 at() 成员函数，例如 :
values.at (4) = values.at(3) + 2.O*values.at(1);这行代码和前一行语句实现的功能相同，其次当传给 at() 的索引是一个越界值时，程序会抛出 std::out_of_range 异常。因此当需要访问容器中某个指定元素时，建议大家使用 at()，除非确定索引没有越界。
读者可能有这样一个疑问，即为什么 array 容器在重载 [] 运算符时，没有实现边界检查的功能呢？答案很简单，因为性能。如果每次访问元素，都去检查索引值，无疑会产生很多开销。当不存在越界访问的可能时，就能避免这种开销。
除此之外，array 容器还提供了 get<n> 模板函数，它是一个辅助函数，能够获取到容器的第 n 个元素。需要注意的是，该模板函数中，参数的实参必须是一个在编译时可以确定的常量表达式，所以它不能是一个循环变量。也就是说，它只能访问模板参数指定的元素，编译器在编译时会对它进行检查。
下面代码展示了如何使用 get<n> 模板函数：
#include <iostream>
#include <array>
#include <string>
using namespace std;
int main()
{
array<string, 5> words{ "one","two","three","four","five" };
cout << get<3>(words) << endl; // Output words[3]
//cout << get<6>(words) << std::endl; //越界，会发生编译错误
return 0;
}
//fourarray 容器提供了 data() 成员函数，通过调用该函数可以得到指向容器首个元素的指针。通过该指针，我们可以获得容器中的各个元素
#include <iostream>
#include <array>
using namespace std;
int main()
{
array<int, 5> words{ 1,2,3,4,5 };
cout << *(words.data() + 1);
return 0;
}
// 2当 array 容器创建完成之后，最常做的操作就是获取其中的元素，甚至有时还会通过循环结构获取多个元素。
可以通过容器名[]的方式直接访问和使用容器中的元素，这和 C++ 标准数组访问元素的方式相同
array<int, 5> words{ 1,2,3,4,5 };
words[4] = words[8];上面代码中，第 8个元素的值被赋值为左边表达式的值。需要注意的是，使用如上这样方式，由于没有做任何边界检查，所以即便使用越界的索引值去访问或存储元素，也不会被检测到。运行会直接弹出错误。
为了能够有效地避免越界访问的情况，可以使用 array 容器提供的 at() 成员函数，例如 :
array<int, 5> words{ 1,2,3,4,5 };
try
{
words.at(4) = words.at(8);
}
catch (const std::exception&)
{
AfxMessageBox("出现异常");
}这行代码和前一行语句实现的功能相同，其次当传给 at() 的索引是一个越界值时，程序会抛出 std::out_of_range 异常。因此当需要访问容器中某个指定元素时，建议大家使用 at()，除非确定索引没有越界。
读者可能有这样一个疑问，即为什么 array 容器在重载 [] 运算符时，没有实现边界检查的功能呢？答案很简单，因为性能。如果每次访问元素，都去检查索引值，无疑会产生很多开销。当不存在越界访问的可能时，就能避免这种开销。
除此之外，array 容器还提供了 get<n> 模板函数，它是一个辅助函数，能够获取到容器的第 n 个元素。需要注意的是，该模板函数中，参数的实参必须是一个在编译时可以确定的常量表达式，所以它不能是一个循环变量。也就是说，它只能访问模板参数指定的元素，编译器在编译时会对它进行检查。
array<string, 5> words{ "one","two","three","four","five" };
cout << get<3>(words) << endl; // Output words[3]
//cout << get<6>(words) << std::endl; //越界，会发生编译错误array 容器提供了 data() 成员函数，通过调用该函数可以得到指向容器首个元素的指针。通过该指针，我们可以获得容器中的各个元素，例如：
array<int, 5> words{1,2,3,4,5};
cout << *( words.data()+1);array 容器提供的 size() 函数能够返回容器中元素的个数（函数返回值为 size_t 类型）
array<int, 5> values{ 1,2,3,4,5 };
size_t i = values.size();
通过调用 array 容器的 empty() 成员函数，即可知道容器中有没有元素（如果容器中没有元素，此函数返回 true）
array<int, 5> values{ 1,2,3,4,5 };
if (values.empty())
AfxMessageBox("The container has no elements.");
else
AfxMessageBox("The container has elements.");
很少会创建空的 array 容器，因为当生成一个 array 容器时，它的元素个数就固定了，而且无法改变，所以生成空 array 容器的唯一方法是将模板的第二个参数指定为 0，但这种情况基本不可能发生。
array 容器之所以提供 empty() 成员函数的原因，对于其他元素可变或者元素可删除的容器（例如 vector、deque 等）来说，它们使用 empty() 时的机制是一样的，因此为它们提供了一个一致性的操作。
除了借助 size() 外，对于任何可以使用迭代器的容器，都可以使用基于范围的循环，因此能够更加简便地计算容器中所有元素的和，比如：
double total = 0;
for(auto&& value : values)
total += value;总结：
#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和 C++ 普通数组存储数据的方式一样，C++ 标准库保证使用 array 容器存储的所有元素一定会位于连续且相邻的内存中
array<int, 5>a{1,2,3};
cout << &a[2] << " " << &a[0] + 2 << endl;
//输出结果为： 004FFD58 004FFD58
strcpy(&a[0], "csdn");
strcpy(a.data(), "csdn");可以看到，a 容器中 &a[2] 和 &a[0] + 2 是相等的。因此在实际编程过程中，我们完全有理由去尝试，在原本使用普通数组的位置，改由 array 容器去实现。
用 array 容器替换普通数组的好处是，array 模板类中已经封装好了大量实用的方法，在提高开发效率的同时，代码的运行效率也会大幅提高。
注意，array 容器的大小必须保证能够容纳复制进来的数据，而且如果是存储字符串的话，还要保证在存储整个字符串的同时，在其最后放置一个\0作为字符串的结束符。此程序中，strcpy() 在拷贝字符串的同时，会自动在最后添加\0。
用 array 容器代替普通数组，最直接的好处就是 array 模板类中已经为我们写好了很多实用的方法，可以大大提高我们编码效率。例如，array 容器提供的 at() 成员函数，可以有效防止越界操纵数组的情况；fill() 函数可以实现数组的快速初始化；swap() 函数可以轻松实现两个相同数组（类型相同，大小相同）中元素的互换。
当两个 array 容器满足大小相同并且保存元素的类型相同时，两个 array 容器可以直接直接做赋值操作，即将一个容器中的元素赋值给另一个容器
如果其保存的元素也支持比较运算符，就可以用任何比较运算符直接比较两个 array 容器。
array<char, 50>addr1{"csdn"};
array<char, 50>addr2{ "csdn_断点" };
//addr1 = addr2; 当两个 array 容器满足大小相同并且保存元素的类型相同时，两个 array 容器可以直接直接做赋值操作，即将一个容器中的元素赋值给另一个容器。
addr1.swap(addr2);
printf("addr1 is：%s\n", addr1.data());
printf("addr2 is：%s\n", addr2.data());
array<char, 50>addr1{ "csdn" };
array<char, 50>addr2{ "csdn_断点" };
if (addr1 == addr2) {
std::cout << "addr1 == addr2" << std::endl;
}
if (addr1 < addr2) {
std::cout << "addr1 < addr2" << std::endl;
}
if (addr1 > addr2) {
std::cout << "addr1 > addr2" << std::endl;
} 两个容器比较大小的原理，和两个字符串比较大小是一样的，即从头开始，逐个取两容器中的元素进行大小比较（根据 ASCII 码表），直到遇到两个不相同的元素，那个元素的值大，则该容器就大。
总之，读者可以这样认为，array 容器就是普通数组的“升级版”，使用普通数组能实现的，使用 array 容器都可以实现，而且无论是代码功能的实现效率，还是程序执行效率，都比普通数组更高。
以下博客部分内容借鉴自：http://c.biancheng.net/stl/。
C++ STL 容器、迭代器、适配器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/120052137 C++ STL deque容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118676574
C++ STL vector容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118676109
C++ STL list容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118676917
C++ STL forward_list容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118687348
C++ STL array 容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118688364
C++ STL pair 类模板(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118714852
C++ STL map容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118741670
C++ STL map emplace()和emplace_hint()(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118771777
C++ STL multimap容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118773021
C++ STL Set容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/118918940
C++ STL multiset容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119624779
C++ STL unordered_map容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119689199
C++ STL unordered_set容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119709019
C++ STL unordered_multiset容器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119709079
C++ STL stack容器适配器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119723782
C++ STL queue容器适配器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119746246
C++ STL priority_queue容器适配器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119770527
C++ STL reverse_iterator反向迭代器适配器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119814820
C++ STL insert_iterator插入迭代器适配器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119834378
C++ STL stream_iterator流迭代器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119834429
C++ STL streambuf_iterator流缓冲区迭代器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119850048
C++ STL move_iterator移动迭代器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/119859888
C++ STL advance()函数(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/120008250
C++ STL distance()函数(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/120008300
C++ STL iterator迭代器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/120008346
C++ STL const_iterator转换为iterator类型迭代器(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/120008324
C++ STL begin()和end()函数(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/120008459
C++ STL prev()和next()函数(深入了解,一文学会) https://blog.csdn.net/qq_37529913/article/details/120008481