C++ Array 和 Vector容器

C++ Array 和 Vector容器

Array

array是c++ 11新增的序列容器，和其他容器的区别是，array的大小是固定的，无法动态扩展或者收缩。这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。在使用该容器之前，代码中需引入 <array> 头文件

初始化

#include <array>

std::array<double, 10> values;

由此，就创建好了一个名为 values 的 array 容器，其包含 10 个浮点型元素。但是，由于未显式指定这 10 个元素的值，因此使用这种方式创建的容器中，各个元素的值是不确定的（array 容器不会做默认初始化操作）。
通过如下创建 array 容器的方式，可以将所有的元素初始化为 0 或者和默认元素类型等效的值：

std::array<double, 10> values {};

当然，在创建 array 容器的实例时，也可以像创建常规数组那样对元素进行初始化：

std::array<double, 10> values {0.5,1.0,1.5,2.0};

可以看到，这里只初始化了前 4 个元素，剩余的元素都会被初始化为 0.0。

成员函数

array 容器还提供有很多功能实用的成员函数。

• 迭代器函数：begin(),end(),cbegin(),cend(),rbegin(),rend(),crbegin(),crend()。
• size() == max_size()返回容器中当前元素的数量，其值始终等于初始化 array 类的第二个模板参数 N。
• empty()判断容器是否为空，和通过size()==0判断条件功能相同，但效率更高。
• at() 返回容器中 n 位置处元素的引用，该函数自动检查 n 是否在有效的范围内，如果不是则抛出 out_of_range 异常。用at()访问相比下标方式更安全，但是因为多了安全检查性能更低。
• front(),back() 返回容器中第一个元素和最后一个元素的直接引用，该函数不适用于空的 array 容器。
• data() 返回一个指向容器首个元素的指针。利用该指针，可实现复制容器中所有元素等类似功能(values.data() == & values[0] == values.begin())。
• fill(val) 将 val 这个值赋值给容器中的每个元素。
• array1.swap(array2) 交换 array1 和 array2 容器中的所有元素，但前提是它们具有相同的长度和类型。

另外，在<array>头文件中还重载了get()全局函数，该重载函数的功能是访问容器中指定的元素，并返回该元素的引用。需要注意的是，该模板函数中，参数的实参必须是一个在编译时可以确定的常量表达式，所以它不能是一个循环变量。也就是说，它只能访问模板参数指定的元素，编译器在编译时会对它进行检查。

std::cout << std::get<3>(values) << std::endl;

array遍历

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 i = values.begin(); i < values.end(); i++) {
	cout << *i << " ";
}

#include <numeric>
int result = accumulate(values.begin(), values.end(), 0);

Vector

vector 容器是 STL 中最常用的容器之一，它和 array 容器非常类似，都可以看做是对 C++ 普通数组的“升级版”。不同之处在于，array 实现的是静态数组（容量固定的数组），而 vector 实现的是一个动态数组，即可以进行元素的插入和删除，在此过程中，vector 会动态调整所占用的内存空间，整个过程无需人工干预。

vector 常被称为向量容器，因为该容器擅长在尾部插入或删除元素，在常量时间内就可以完成，时间复杂度为 O(1)O(1)；而对于在容器头部或者中部插入或删除元素，则花费时间要长一些（移动元素需要耗费时间），时间复杂度为线性阶 O(n)O(n)。

初始化

• vector():创建一个空vector
• vector(int nSize):创建一个vector,元素个数为nSize
• vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t
• vector(const vector&):复制构造函数
• vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中

std::vector<double> values;

注意，这是一个空的 vector 容器，因为容器中没有元素，所以没有为其分配空间。当添加第一个元素（比如使用 push_back() 函数）时，vector 会自动分配内存。

在创建好空容器的基础上，还可以像下面这样通过调用 reserve() 成员函数来增加容器的容量：

values.reserve(20);

这样就设置了容器的内存分配，即至少可以容纳 20 个元素。注意，如果 vector 的容量在执行此语句之前，已经大于或等于 20 个元素，那么这条语句什么也不做；另外，调用 reserve() 不会影响已存储的元素，也不会生成任何元素，即 values 容器内此时仍然没有任何元素。

还需注意的是，如果调用 reserve() 来增加容器容量，之前创建好的任何迭代器（例如开始迭代器和结束迭代器）都可能会失效，这是因为，为了增加容器的容量，vector<T> 容器的元素可能已经被复制或移到了新的内存地址。所以后续再使用这些迭代器时，最好重新生成一下。

除了创建空 vector 容器外，还可以在创建的同时指定初始值以及元素个数，比如：

std::vector<int> primes {2, 3, 5, 7, 11, 13, 17, 19};

这样就创建了有8个元素的 vector 容器。

在创建 vector 容器时，也可以指定元素个数：

std::vector<double> values(20);

注意，圆括号 () 和大括号 {} 是有区别的，前者（例如 (20) ）表示元素的个数，而后者（例如 {20} ） 则表示 vector 容器中只有一个元素 20。

第二个参数指定了所有元素的初始值，因此这 20 个元素的值都是 1.0。

std::vector<double> values(20, 1.0);

还可以通过一个vector初始化另一个vector，或者一个vector的迭代器范围初始化另一个vector

std::vector<int> primes {2, 3, 5, 7, 11, 13, 17, 19};

std::vector<int> other_primes(primes);
std::vector<int> third_primes(primes.begin()+3, primes.end());

一些特殊初始化

初始化二维数组时，可以先确定第一维大小时，初始化如下：

下面两种方法效果完全相同。

vector<vector<int>> nums(10);

vector<vector<int>> nums(10, vector<int>());

需要初始化二维零数组时，可以这样初始化：

// 初始化二维 10x10 的0数组
vector<vector<int>> nums(10, vector<int>(10, 0));

需要将 vector 从 0 开始初始化：

vector<int> nums(10);

iota(nums.begin(), nums.end(), 0);
// nums = [0, 1, 2, ..., 8, 9]

成员函数

• 迭代器函数：同array

增加数据

• void push_back(const T& x):向量尾部增加一个元素X
• iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
• iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
• iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

删除数据

• iterator erase(iterator it):删除向量中迭代器指向元素
• iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
• void pop_back():删除向量中最后一个元素
• void clear():清空向量中所有元素

迭代器

• reference at(int pos):返回pos位置元素的引用
• reference front():返回首元素的引用
• reference back():返回尾元素的引用
• iterator begin():返回向量头指针，指向第一个元素
• iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
• reverse_iterator rbegin():反向迭代器，指向最后一个元素
• reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

其他函数

• size() 返回实际元素个数
• max_size() 返回元素个数的最大值。这通常是一个很大的值，一般是 232−1232−1，所以我们很少会用到这个函数。
• resize() 改变实际元素个数
• capacity() 返回当前容量
• reserve() 改变容器容量
• shrink_to_fit() 将内存减少到等于当前元素实际所使用的大小。
• at() 使用经过边界检查的索引访问元素，同array。
• operator[ ] 重载了 [ ] 运算符，可以向访问数组中元素那样，通过下标即可访问甚至修改 vector 容器中的元素
• front(), back() 分别是第一个和最后一个元素的引用
• data() 返回指向容器中第一个元素的指针。
• emplace() 在指定的位置直接生成一个元素。
• emplace_back() 在序列尾部生成一个元素。

vector内存分配

和 array 容器不同，vector 容器可以随着存储元素的增加，自行申请更多的存储空间。因此，在创建 vector 对象时，我们可以直接创建一个空的 vector 容器，并不会影响后续使用该容器。
但这会产生一个问题，即在初始化空的 vector 容器时，不能使用迭代器。也就是说，如下初始化 vector 容器的方法是不行的：

#include <iostream>
#include <vector>
int main()
{
    std::vector<int> values;
    int val = 1;
    for (auto first = values.begin(); first < values.end(); ++first, val++) {
        *first = val;
    }
    return 0;
}

除此之外，vector 容器在申请更多内存的同时，容器中的所有元素可能会被复制或移动到新的内存地址，这会导致之前创建的迭代器失效。

#include <iostream>
#include <vector>
int main(int argc, char const *argv[])
{
	std::vector<int> v(1);
	auto begin = &v[0]; // v.data() == &v[0]
	int times = 0;
	for (int i = 0; i < 10000000; ++i)
	{
		v.push_back(i);
		if (begin != &v[0])
		{
			times++;
			std::cout << "vector reallocator "<<times << " times" << " ......" << std::endl;
			begin = &v[0];
		}
	}
	return 0;
}

数据访问

std::vector<int> values{1,2,3,4,5};
// 输出第三个数
std::cout << *(values.data() + 2) << std::endl;
std::cout << values.at(2) << std::endl;
std::cout << values[2] << std::endl;

数据遍历

std::vector<int> values{1,2,3,4,5};

// 使用迭代器遍历
for(auto it = values.begin(); it!= values.end(); it++)
{
	std::cout << *it << std::endl;
}
// 使用下标
for(size_t i = 0; i < values.size(); i++)
{
	std::cout << values[i] << std::endl;
}
// c++11 新方法
for(auto &i: values)
{
	std::cout << i << std::endl;
}