一、结构视图

二、代码

#include<iostream>
#include <algorithm>
#include <list>
#include <vector>
#include <string>
//array 容器的大小是固定的，无法动态的扩展或收缩，它只允许访问或者替换存储的元素。
//它比普通数组更安全，且效率并没有因此变差。
//array<T,N> T 用于指明容器中的存储的具体数据类型，N 必须是常量用于指明容器的大小。
//array 容器以类模板的形式定义在 <array> 头文件，并位于命名空间 std 中
#include <array>
using namespace std;
#define Num 10
#define N 0

//创建array
void test1()
{
	//测试使用变量
	const int n = 10;

	array<int, 10> arrtest11;					//创建具有 10 个 double 类型元素的 array 容器
	array<int, 10> arrtest12{};					//创建，将所有的元素初始化为 0 或者和默认元素类型等效的值
	array<int, 10> arrtest13{ 1,2,3 };			//创建并指定初始化值
	array<int, n> arrtest14{};					//const常量
	array<int, Num> arrtest15{};				//宏定义常量

	//输出测试
	for (int i = 0; i < n; i++)
		cout << arrtest14[i] << " ";
	cout << endl;
	for (int i = 0; i < Num; i++)
		cout << arrtest15[i] << " ";
	cout << endl;

	typedef array<int, 4> arrtest1;//模板
	arrtest1 c0 = { 0, 1, 2, 3 };
}

//array迭代器用法
void test2()
{
	//测试使用变量
	array<int, 5>arrtest2{ 1,2,3,4,5 };

	auto a = arrtest2.begin();				//返回指向容器中第一个元素的迭代器。同begin(arrtest2)
	auto b = arrtest2.end();				//返回指向容器最后一个元素所在位置后一个位置的迭代器。同end(arrtest2)
	while (a != b)
	{
		cout << *a << " ";
		++a;
	}
	cout << endl;
	auto c = arrtest2.rbegin();				//返回指向最后一个元素的迭代器。
	auto d = arrtest2.rend();				//返回指向第一个元素所在位置前一个位置的迭代器。
	while (c != d)
	{
		cout << *c << " ";
		++c;
	}
	cout << endl;
	auto e = arrtest2.cbegin();				//和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
	auto f = arrtest2.cend();				//和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
	while (e != f)
	{
		cout << *e << " ";
		++e;
	}
	cout << endl;
	auto g = arrtest2.crbegin();			//和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
	auto h = arrtest2.crend();				//和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
	while (g != h)
	{
		cout << *g << " ";
		++g;
	}
	cout << endl;
	for (auto first = arrtest2.begin(); first != arrtest2.end(); ++first)//使用for循环输出
	{
		cout << *first << " ";
	}

	//唯一的区别在于其返回的迭代器能否用来修改元素值。
	//*a, b, c, d = 10; 可以修改
	//*e, f, g, h = 10; 不能修改元素
}

//array访问元素
void test3()
{
	//测试使用变量
	array<int, 5> arrtest3{ 1,2,3,4,5 };
	int n;

	//数组形式访问和修改
	cout << arrtest3[0] << endl;
	arrtest3[0] = 0;
	cout << arrtest3[0] << endl;
	//at() 成员函数,能够有效地避免越界访问的情况
	cout << arrtest3.at(0) << endl;
	arrtest3[0] = 1;
	cout << arrtest3.at(0) << endl;
	//get<n> 模板函数,获取到容器的第 n 个元素
	//参数的实参必须是一个在编译时可以确定的常量表达式，所以它不能是一个循环变量
	cout << get<N>(arrtest3) << endl;
	//data() 成员函数,得到指向容器首个元素的指针
	cout << *(arrtest3.data() + 1) << endl;
	//访问最后一个元素
	cout << arrtest3.back() << endl;

	//size() 函数返回容器中元素的个数
	n = arrtest3.size();
	for (int i = 0; i < n; i++)
		cout << arrtest3[i] << " ";
	cout << endl;
}

//swap测试
void test4()
{
	typedef array<int, 4> arrtest4;//模板
	arrtest4 c0 = { 0, 1, 2, 3 };
	arrtest4 c1 = { 4, 5, 6, 7 };

	// display contents " 0 1 2 3"
	for (arrtest4::const_iterator it = c0.begin(); it != c0.end(); ++it)
		cout << " " << *it;
	cout << endl;//0123

	c0.swap(c1);
	for (arrtest4::const_iterator it = c0.begin(); it != c0.end(); ++it)
		cout << " " << *it;
	cout << endl;//4567

	swap(c0, c1);
	for (arrtest4::const_iterator it = c0.begin(); it != c0.end(); ++it)
		cout << " " << *it;
	cout << endl;//0123
}

//array运算符
void test5()
{
	typedef array<int, 4> arrtest5;//模板
	arrtest5 c0 = { 0, 1, 2, 3 };
	arrtest5 c1 = { 4, 5, 6, 7 };

	//!不等于 ==等于
	cout << boolalpha << " " << (c0 != c1) << endl;//true
	cout << boolalpha << " " << (c0 == c1) << endl;//false

	//<小于	<=小于等于 >大于 >=大于等于
	cout << boolalpha << " " << (c0 < c1) << endl;//true
	cout << boolalpha << " " << (c0 > c1) << endl;//false
	cout << boolalpha << " " << (c0 <= c1) << endl;//true
	cout << boolalpha << " " << (c0 >= c1) << endl;//false

	c0 = c1;//赋值
	c0[1];//重载[]
}

//其他用法
void test6()
{
	typedef std::array<int, 4> arrtest6;
	arrtest6 arrtest61 = { 0, 1, 2, 3 };

	cout << boolalpha << " " << arrtest61.empty();//判空
	cout << " " << arrtest61.max_size();//长度
	cout << " " << arrtest61.size();
	arrtest61.fill(3);//清空并赋值3
}

int main()
{
	//test1();
	//test2();
	//test3();
	//test4();
	//test5();
	//test6();
	return 0;
}