模板类vector：
模板类vector类似string类，是一种动态数组。
比如说，string类可以将一个string的字符串插入到另外一个string类字符串后面。vector也可以有类似的功能。
而对于vector类来说，他是一个数组，比如我们数组中有第一个A和第二个元素B，然后我们可以把C插入在A和B之间，这个时候，数组第一个成员为A，第二个为C，第三个为B。
我们还可以把其中一个成员删掉，这样，后面两个成员自动向前进一位，比如删掉第一个成员A，于是第一个成员变成了C，第二个成员变成了B。
头文件：
#include<vector>//使用vector类需要引用头文件vector
创建vector类数组：
vector<类型名>数组名(成员个数);
比如：
vector<double>vd(n);
注意：成员个数可以为变量，这样在使用的时候更*。
给vector数组成员赋值：
可以像使用普通数组一样，使用 变量名[编号] 来进行赋值，注意：第一个成员的编号为0，和数组是一样的。例如：
vd[1] = 22;
数组vd的第二个成员的值为22。
注意：vector类在声明并初始化的时候。分三种情况：
①声明成员个数，不赋值；
②声明成员个数，赋相同的值；
③不声明成员个数，赋不同的值，赋值几个成员就是有几个成员。
如代码：
#include<iostream>
#include<vector>
int main()
{
using namespace std;
vector<double>aaa(3); //原型：vector<类型名>数组名(数组成员数);
cout << "原型数组aaa.size() = " << aaa.size() << endl;
vector<int>a(3, 4); //变型1（声明并初始化多个数值一样的成员）：vector<类型名>变量名(成员个数，值且同时给每个成员都赋值);
cout << "变型1，数组a，初始化时同时给多个数组成员赋 相同值\n";
cout << "a[0] = "<< a[0] << endl; //输出数组a第一个成员
cout << "a[1] = " << a[1] << endl; //输出数组a第二个成员
cout << "a[2] = " << a[2] << endl; //输出数组a第三个成员
cout << "数组a.size() = " << a.size() << endl; //显示数组a的成员数
vector<int>b = { 1,2,3,4 }; //变型2（声明并初始化数组成员）：vector<类型名>数组名{成员1的值,成员2的值,……};
//注意，给不同成员赋 不同的值 是用大括号，不写成员个数。
//给不同成员赋 相同的值 是写在小括号里，写在成员个数之后
cout << "变型2，数组b，初始化并给数组成员赋不同的值，需要c++11\n";
cout << "b[0] = " << b[0] << endl;
cout << "b[1] = " << b[1] << endl;
cout << "b[2] = " << b[2] << endl;
cout << "b[3] = " << b[3] << endl;
cout << "b.size() = " << b.size() << endl;
vector<int>c{ 8,9 }; //变型3（和变型2相同，只不过省略了等号）：vector<类型名>数组名{成员1,成员2……};
cout << "变型3，数组c，初始化时赋不同的值，需要C++11\n";
cout << "c[0] = " << c[0] << endl;
cout << "c[1] = " << c[1] << endl;
//vector<int>d(3) = { 1, 3,5 };
//注：这种想在初始化时，确定成员个数比如3个，然后给第一个和第二个成员赋值的方式是不可行的。
//即使同时给3个成员都赋值，也是不可行的。
//要么是不写成员个数，给成员赋不同的值（赋值几个成员就是有几个成员）；
//要么是写成员个数，给成员赋相同的值；
//要么是写成员个数，不给成员赋值；
system("Pause");
return 0;
}
输出：
原型数组aaa.size() = 3
变型1，数组a，初始化时同时给多个数组成员赋 相同值
a[0] = 4
a[1] = 4
a[2] = 4
数组a.size() = 3
变型2，数组b，初始化并给数组成员赋不同的值，需要c++11
b[0] = 1
b[1] = 2
b[2] = 3
b[3] = 4
b.size() = 4
变型3，数组c，初始化时赋不同的值，需要C++11
c[0] = 8
c[1] = 9
请按任意键继续. . .
在vector类的数组中插入一个成员：
使用命令 数组名.insert(数组名.begin()+插入位置,插入的成员);
例如，给vd数组的第二个位置插入一个成员，成员的值为a（a可以是变量名，也可以是常量，但需要已经初始化）。如代码：
vd.insert(vd.begin()+1, a);
注意：插入到第二个位置，是+1，而原来数组第二个位置的成员，将依次向后退一位，比如原来第二个位置的成员，在插入后就在第三个位置了。
删除vector类数组中的一个成员：
使用命令 数组名.erase(数组名.begin()+删除位置):
比如，删除vd数组第一个成员，那么删除位置就应该写0。注意，数组第一个位置的编号是0。如代码：
vd.erase(vd.begin() + 0);
在vector类数组的尾部插入一个成员：
即在数组的最后插入一个成员，这个成员的插入，增加了数组成员的个数。代码为： 数组名.push_back(数组成员);
例如在数组最后加入成员10，代码：
vd.push_back(10);
vector类数组的成员数：
数组成员数是可以变的，用 数组名.size() 可以显示成员的数量。——按照某个帖子的说法是 向量大小 。
①在创建并声明时，成员数为声明时的成员数，即使某个成员并没有被赋值，也会被算入在内。
②在插入成员，无论是在中间插入或者是在尾部插入，都会增加成员数。
③在删除成员时，也会相应减少成员数。
代码是：
cout << "vd数组的宽度为：" << vd.size() << endl << endl;//显示数组的成员数
将一个vector数组赋值给另外一个vector数组：
当两个数组类型相同，（元素数无需相同），可以进行赋值。
格式为：目标数组名=源数组名;
上代码：
#include<iostream>
#include<vector> //使用vector类需要引用头文件vector
int main()
{
using namespace std;
int n; //声明变量n
cout << "输入vector类的数组元素个数（请大于等于3）：" << endl;
cin >> n; //要求用户输入变量n
vector<double>vd(n); //创建一个double类型的vector动态数组，数组元素为n个，数组名为vd
//即 vector<类型名>数组名(成员数量)，注意，成员数量可以为变量
cout << "输入vd[0]：";
cin >> vd[0]; //调用的时候，用vector类的数组名加元素编号，第一个元素编号为0，同数组。要求用户输入vd[0]的值
cout << "将vd[1]赋值22。" << endl;
vd[1] = 22; //给vd[1]，即数组中第2个成员，赋值22
cout << "vd[0]为" << vd[0] << "。vd[1]为" << vd[1] << endl;
cout << "vd数组的宽度为：" << vd.size() << endl << endl; //显示数组的成员数
int a = 1;
vd.insert(vd.begin() + 1, a); //在数组中第二个位置插入变量a
cout << "现在，创建常量a=1，然后将a插入在vd[1]之前，即把a插入到vd[1]的位置，原来的vd[1]依次顺延到下一位。" << endl;
cout << "vd[0]为" << vd[0] << "。vd[1]为" << vd[1];
cout << "vd[2]为：" << vd[2] << endl; //原本第二个位置的成员被顺延到第三个位置了
cout << "vd数组的宽度为：" << vd.size() << endl << endl; //显示数组的成员数
vd.erase(vd.begin() + 0); //删除数组中第一个成员，其他成员依次向前进一位
cout << "现在，删除vd[0]当前成员，原来的vd[1]就变成vd[0]了。" << endl;
cout << "vd[0]为" << vd[0] << "。vd[1]为" << vd[1] << endl;
cout << "vd数组的宽度为：" << vd.size() << endl << endl; //显示数组的成员数
//n = 5; //虽然上面vd[n]声明了数组的成员数，但单纯更改变量n，其实是不能改变vd数组的成员个数的。
int b = 2, c = 3, d = 4; //声明新的变量bcd并初始化
vd.insert(vd.begin() + 2, b); //在第三个位置插入成员b
vd.insert(vd.begin() + 3, c); //在第四个位置插入成员c
vd.insert(vd.begin() + 4, d); //在第五个位置插入成员d
cout << "从第三个位置依次插入b=2，c=3，d=4" << endl;
cout << "目前，vd[0]为" << vd[0] << "。vd[1]为" << vd[1] << "。vd[2]为" << vd[2] << "。vd[3]为" << vd[3] << "。vd[4]为" << vd[4] << endl;
cout << "vd数组的宽度为：" << vd.size() << endl << endl; //显示数组的成员数
//vd.erase(vd.begin() + 1, vd.end() + 2);
//按照说法，这行代码可以删除多个数组成员，但实际测试中却出错了。
vd.push_back(10); //在数组的最后插入成员，值为10
cout << "在vd数组的尾部插入常量10。" << endl;
cout << "第" << n + 4 << "个元素是数组的最后一个元素，vd[" << n + 3 << "]的值为：" << vd[n + 3] << endl; //注意，这行是可以通过变量来显示相应的数组的成员的，比如vd[n+3]是数组第n+4个成员
cout << "vd数组的宽度为：" << vd.size() << endl << endl; //显示数组的成员数
vector<double>bb(20); //创建vector类数组bb，因为要将vd数组赋值给bb数组，因此成员数不重要
bb = vd; //将vd数组赋值给bb数组，二者将完全等同
cout << "将vd数组赋值给bb数组\n";
cout << "bb数组第四个成员bb[3]=" << bb[3] << endl;
cout << "bb数组的成员数为：" << bb.size() << endl;
system("pause");
return 0;
}
输出：
输入vector类的数组元素个数（请大于等于3）：
33
输入vd[0]：55
将vd[1]赋值22。
vd[0]为55。vd[1]为22
vd数组的宽度为：33
现在，创建常量a=1，然后将a插入在vd[1]之前，即把a插入到vd[1]的位置，原来的vd[1]依
次顺延到下一位。
vd[0]为55。vd[1]为1vd[2]为：22
vd数组的宽度为：34
现在，删除vd[0]当前成员，原来的vd[1]就变成vd[0]了。
vd[0]为1。vd[1]为22
vd数组的宽度为：33
从第三个位置依次插入b=2，c=3，d=4
目前，vd[0]为1。vd[1]为22。vd[2]为2。vd[3]为3。vd[4]为4
vd数组的宽度为：36
在vd数组的尾部插入常量10。
第37个元素是数组的最后一个元素，vd[36]的值为：10
vd数组的宽度为：37
将vd数组赋值给bb数组
bb数组第四个成员bb[3]=3
bb数组的成员数为：37
请按任意键继续. . .
模板类array（限C++11）：
vector类比数组强大，但是代价是效率较低（不知道为什么，因为使用的是动态存储区么？），如果是长度固定的数组（因为vector是动态数组，可以增加成员或者减少成员），使用数组更高，但代价是不那么安全和方便（不方便我知道，但是不安全是为什么？）。
因此，c++11增加了模板类array，使用的是栈（静态存储区）（vector是堆，动态存储区），位于名称空间std之中。
因此array效率和数组相同，但是更安全和方便，要创建array对象，需要包含头文件array。array对象的创建和语法与vector稍有不同。
头文件：
#include <array>//使用模板array需要调用头文件array
声明和创建：
声明一个array类数组和vector数组方式不同，格式为： array<类型名,成员数常量>数组名;
例如创建一个int类型，成员数为3，数组名为a的array类的代码为：
array<int, 3> a;
注意：①vector的成员数是可变的，而array的成员数是固定的。
②vector和array都是<>括号，而不是小括号()。
初始化和赋值：
因为和数组类似，所以初始化和赋值的方式类似数组。
初始化的格式为： array<类型名,成员数>数组名={成员1,成员2,……};
赋值格式为： 数组名[编号]=常量;
例如，初始化数组a的前2个成员的代码为：
array<int, 3> a = { 1,2 };
给a的第三个成员赋值的代码为：
a[2] = 4;
显示成员数：
与vector类相同，显示成员数的代码为： 数组名.size()
例如代码：
cout << a.size() << endl;
上代码：
<pre name="code" class="cpp">#include<iostream>
#include<array> //使用模板array需要调用头文件array
int main()
{
using namespace std;
array<int, 5> a = { 1,2 }; //创建array类数组a，成员数为5，类型为int类，并为前2个成员赋值
a[2] = 4; //为第三个成员赋值
cout << a[0] << endl; //显示第一个成员的值
cout << "请为数组第四个成员赋值：" << endl;
cin >> a[3]; //读取用户输入，为第四个成员赋值
cout << "第四个成员的值为" << a[3] << endl; //显示第四个成员的值
cout << "数组的成员数为：" << a.size() << endl; //显示成员数
array<int, 5 >b; //创建数组b
b = a; //由于数组和数组a的类型相同，成员数相同，故可以将数组a赋值给数组b
cout << "array类数组b等于数组a，b的第二个元素为b[1]=" << b[1] << endl; //显示数组b第2个元素，和数组a第二个元素相同
system("pause");
return 0;
}
输出：
1
请为数组第四个成员赋值：
55
第四个成员的值为55
数组的成员数为：5
array类数组b等于数组a，b的第二个元素为b[1]=2
请按任意键继续. . .
vector对象、array对象和普通数组之间的相同和差异：
普通数组 |
vector类 |
array类 |
备注 |
|
表示数组成员 |
数组名[编号] |
数组名[编号] |
数组名[编号] |
第一个成员编号为0，后面一次类推 |
将一个数组赋值给另外一个数组 |
不可 |
可，需类型数相同 |
可，类型和成员数需相同 |
|
显示成员数 |
size(数组名) |
数组名.size() |
数组名.size() |
|
头文件 |
无需 |
vector |
array |
|
名称空间 |
无需 |
std |
std |
|
声明时，进行初始化赋值 |
可 |
可，但不同于其他两类。具体见前文。 |
可 |
|
数组成员数变更 |
不可 |
可 |
不可 |
|
在数组成员之间插入新成员 |
不可 |
可 |
不可 |
|
删除现有数组成员 |
不可 |
可 |
不可 |
|
使用内存空间 |
使用栈（静态内存分配） |
使用堆（*存储空间） |
使用栈（静态内存分配） |
|
初始化成员数 |
常量 |
常量或者变量 |
常量 |
|
能否访问数组范围外的数据 |
可 |
可 |
可 |
例如数组名[-40]或者数组名[100] |
能否使用 数组名.at(编号)检查是否在数组的范围外 |
不可 |
可 |
可 |
例如array<int, 4>a= { 1,2,3,4 }; cout << a.at(-1) << endl; 会在运行时提示出错 |