本文详细介绍了C++STL中的vector容器，包括其作为可变大小数组的特点，动态扩容策略，迭代器的使用以及空间增长问题。还讨论了reserve和resize方法，以及如何处理迭代器失效和杨辉三角的生成。
vector的介绍及使用
1. vector
是表示可变大小数组的序列容器。
2.
就像数组一样，
vector
也采用的连续存储空间来存储元素。也就是意味着可以采用下标对
vector
的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3.
本质讲，
vector
使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是 一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector
分配空间策略：
vector
会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5.
因此，
vector
占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6.
与其它动态序列容器相比（
deque, list and forward_list
），
vector
在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list
和
forward_list统一的迭代器和引用更好。
vector的定义
(1)vector<int> a;//无参构造
(2)vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
(3)vector<int> a(b); //用b向量来创建a向量，整体复制性赋值，拷贝构造
(4)vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素
(5) vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），初值默认0。
(6)int b[7]={1,2,3,4,5,9,8}; vector<int> a(b,b+7); //从数组中获得初值
vector iterator 的使用
vector 空间增长问题
#include<iostream>
using namespace std;
#include<vector>
int main()
{
vector<int> v;
cout << v.size()<<endl;//0
cout << v.capacity() << endl;//0
cout << v.empty() << endl;//1
return 0;
}capacity 的代码在 vs 和 g++ 下分别运行会发现， vs 下 capacity 是按 1.5 倍增长的， g++ 是按 2 倍增长的 。这个问题经常会考察，不要固化的认为， vector 增容都是 2 倍，具体增长多少是根据具体的需求定义的。vs 是 PJ 版本 STL ， g++ 是 SGI 版本 STL 。reserve 只负责开辟空间，如果确定知道需要用多少空间， reserve 可以缓解 vector 增容的代价缺陷问题。resize 在开空间的同时还会进行初始化，影响 size 。
#include<iostream>
#include<algorithm>
using namespace std;
#include<vector>
int main()
{
// 测试vector的默认扩容机制
size_t sz;
vector<int> v;
sz = v.capacity();
cout << "making v grow:\n";
for (int i = 0; i < 100; ++i)
{
v.push_back(i);
if (sz != v.capacity())
{
sz = v.capacity();
cout << "capacity changed: " << sz << '\n';
}
}
/*vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
making foo grow :
capacity changed : 1
capacity changed : 2
capacity changed : 3
capacity changed : 4
capacity changed : 6
capacity changed : 9
capacity changed : 13
capacity changed : 19
capacity changed : 28
capacity changed : 42
capacity changed : 63
capacity changed : 94
capacity changed : 141
g++运行结果：linux下使用的STL基本是按照2倍方式扩容
making foo grow:
capacity changed: 1
capacity changed: 2
capacity changed: 4
capacity changed: 8
capacity changed: 16
capacity changed: 32
capacity changed: 64
capacity changed: 128*/
return 0;
}resize
用法： a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，补的话其值默认0，容量不变 a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，补的话其值为2，容量不变
#include<iostream>
using namespace std;
#include<vector>
int main()
{
vector<int> v;
v.resize(10);
cout << v[1] << endl;//0
cout << v.size()<<endl;//10
cout << v.capacity() << endl;//10
return 0;
}reserve
a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能）
#include<iostream>
using namespace std;
#include<vector>
int main()
{
vector<int> v;
v.reserve(10);
cout << v.size()<<endl;//0
cout << v.capacity() << endl;//10
return 0;
}vector 增删查改
a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5a.pop_back(); //删除a向量的最后一个元素
a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4 a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5 a.insert(a.begin(), s.begin(), s.end());//在a的第0个元素（从第0个算起）的位置插入 s[begin,end)的元素 a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的 （从第0个算起）第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8，插入元素后1,4,5,9,2,3,4,5,9,8
a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+3（不包括它）[begin()+1,a.begin()+3) a.erase(a.begin());//删除第0个元素
a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换
#include<iostream> using namespace std; #include<vector> int main() { vector<int> v(10, 1); for (size_t i = 0; i < v.size(); i++) { cout << v[i] << " ";//1 1 1 1 1 1 1 1 1 1 } cout << endl; return 0; }
算法模块 头文件#include<algorithm>，不在vector中 find(a.begin(),a.end(),10); //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置 reverse(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1 [a.begin(),a.end()),左闭右开sort(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列copy(a.begin(),a.end(),b.begin()+1); //把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素
其他
shrink_to_fit
assign
a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2位置的元素构成的向量赋给a a.assign(4,2); //a只含4个元素，且每个元素为2
vector非成员函数
会调用即可
vector模拟实现
#include<iostream>
#include<algorithm>
#include<assert.h>
using namespace std;
namespace bit
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
vector()
{}
// v2(v1)
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}
// vector<int> v1 = { 1,2,3,4,5,6,7,8,9,10 };
vector(initializer_list<T> il)
{
reserve(il.size());
for (auto& e : il)
{
push_back(e);
}
}
// 类模板的成员函数可以是函数模板
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector(size_t n, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
}
vector(int n, const T& val = T())
{
reserve(n);
for (int i = 0; i < n; i++)
{
push_back(val);
}
}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
// v1 = v3
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
~vector()
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
size_t size() const
{
return _finish - _start;
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
size_t capacity() const
{
return _endofstorage - _start;
}
void reserve(size_t n)
{
if (n > capacity())
{
T* tmp = new T[n];
size_t old_size = size();
//memcpy(tmp, _start, size() * sizeof(T));
for (size_t i = 0; i < old_size; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
_start = tmp;
_finish = tmp + old_size;
_endofstorage = tmp + n;
}
}
void resize(size_t n, const T& val = T())
{
if (n > size())
{
reserve(n);
// 插入
while (_finish < _start + n)
{
*_finish = val;
++_finish;
}
}
else
{
// 删除
_finish = _start + n;
}
}
void push_back(const T& val)
{
insert(end(), val);
}
void pop_back()
{
/*assert(!empty());
--_finish;*/
erase(end() - 1);
}
bool empty()
{
return _start == _finish;
}
iterator insert(iterator pos, const T& val)
{
assert(pos >= _start);
assert(pos <= _finish);
if (_finish == _endofstorage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
// 如果扩容了要更新pos
pos = _start + len;
}
iterator it = _finish - 1;
while (it >= pos)
{
*(it + 1) = *it;
--it;
}
*pos = val;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos + 1;
while (it < _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
}
其他注意点
内置类型调用构造函数
括号内为空，默认构造一个值为0的匿名变量，然后赋值给当前变量
int k(1);
这里构造一个值为1名为k的值，不能直接赋值和引用进行初始化
列表初始化—std::initializer_list
读者可能注意到了， C++11 中的 stl 容器拥有和未显示指定长度的数组一样的初始化能力，代码如下：
int arr[] { 1, 2, 3 }; std::map<std::string, int> mm ={{ "1", 1 }, { "2", 2 }, { "3", 3 }}; std::set<int> ss = { 1, 2, 3 }; std::vector<int> arr = { 1, 2, 3, 4, 5 };这里 arr 没有显式指定长度，因此，它的初始化列表可以是任意长度。
同样， std::map、 std::set、 std::vector 也可以在初始化时任意书写需要初始化的内容。
stl 中的容器是通过使用 std::initializer_list 这个轻量级的类模板来完成上述功能支持的
// vector<int> v1 = { 1,2,3,4,5,6,7,8,9,10 };
//vector<int> v1 { 1,2,3,4,5,6,7,8,9,10 };
vector(initializer_list<T> il)
{
reserve(il.size());
for (auto& e : il)
{
push_back(e);
}
}我们原先讲先创建一个临时对象，然后用数据初始化临时对象，最后拷贝构造给v1
实际上先将数据传给轻量级类模板il,从中把数据取出来初始化临时对象,最后拷贝构造给v1
定义一个变量并初始化
int units_sold=0;//直接赋值
int units_sold(0);//先调用构造，构造一个值为0的名为units_sold变量
int units_sold={0}; //列表初始化
int units_sold{0}; //列表初始化
内置类型也可以这样调用列表创建一个临时变量，然后用数据初始化临时变量，最后赋值
//内置类型 int x = 10; int x = {10}; int x{10}; int x = 1+2; int x = {1+2}; int x{1+2}; //数组 int arr[5] = {1,2,3,4,5}; int arr[] = {1,2,3,4,5}; int arr[]{1,2,3,4,5}; //动态数组，C++98不支持 int* parr = new int[5]{1,2,3,4,5}; int* parr = new int[]{1,2,3,4,5}; //标准容器 vector<int> v1{ 1, 2, 3, 4, 5 }; vector<int> v2={ 1, 2, 3, 4, 5 }; map<int, int> m{{1，1},{2,2},{3,3},{4,4}}; //类列表初始化 class Point { public: Point(int x=0,int y=0) :_x(x) ,_y(y) {} private: int _x; int _y; }; int main() { //以下等价 Point p(1, 2); Point p1 = { 1, 2 }; Point p2{ 1, 2 }; }
vector 迭代器失效问题迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了 封装 ，比如： vector 的迭代器就是原生态指针 T* 。因此 迭代器失效，实际就是迭代器底层对应指针所指向的 空间被销毁了，而使用一块已经被释放的空间 ，造成的后果是程序崩溃 (即如果继续使用已经失效的迭代器， 程序可能会崩溃)迭代器失效解决办法：在使用前，对迭代器重新赋值即可
例题精讲
杨辉三角
给定一个非负整数
numRows，生成「杨辉三角」的前numRows行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>> ret(numRows);
for(int i=0;i<numRows;i++)
{
ret[i].resize(i+1);
for(int j=0;j<=i;j++)
{
if(j==0||i==j)
ret[i][j]=1;
else
ret[i][j]=ret[i-1][j-1]+ret[i-1][j];
}
}
return ret;
}
};
扫一扫
2004
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
