- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

C++ Vector 详解

ruochen 发表于 2021/04/11 11:07:15 2021/04/11

【摘要】 C++ Vector 详解

c++ vector

简介

vector 是顺序容器的一种，vector 是可变长的动态数组（可存放任意类型），支持随机访问迭代器。所有 STL 算法都能对 vector 进行操作，要使用 vector，需要包含头文件 vector
优点
- 因其拥有一段连续的内存空间，能非常好的支持随即存取，即[]操作符。
- 根据下标随机访问某个元素的时间是常数，在尾部添加一个元素的时间大多情况下也是常数，总体来说速度很快
缺点
- 若要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低
- 在中间插入或删除元素时，因为要移动多个元素，因此速度较慢，平均花费的时间和容器中的元素个数成正比

函数列表

Constructors 构造函数
Operators 对vector中的元素赋值或比较
assign() // 对vector中的元素赋值
at() // 返回指定元素的位置
back() // 返回最后一个元素
begin() // 返回第一个元素的迭代器
capacity() // 返回vector所能容纳的元素数量（在不重新分配内存的情况下）
clear() // 清空所有元素
empty() // 判断vector是否为空（空返回true）
end() // 返回最末元素的迭代器（实指向最末元素的下一个位置）
erase() // 删除指定元素
front() // 返回第一个元素
get_allocator() // 返回vector的内存分配器
insert() // 插入元素到vector中
max_size() // 返回vector所能容纳元素的最大数量（上限）
pop_back() // 移除最后一个元素
push_back() // 在vector最后添加一个元素
rbegin() // 返回vector尾部的逆迭代器
rend() // 返回vector起始的逆迭代器
reserve() // 设置vector最小的元素容纳数量
resize() // 改变vector元素数量的大小
size() // 返回vector元素数量的大小
seap() // 交换两个vector

函数详解

构造函数
- 语法：
  - vector() // 无参构造函数，将容器初始化为空
  - vector(int n) // 将容器初始化为有 n 个元素
  - vector(int n, const T & val) // 假定元素类型为T，此构造函数将容器初始化为有 n 个元素，每个元素的值都是 val
- 案例
```
vector<int> v1(5, 6);  // 构造了包含5个值为6的元素的vector
```

assign 函数

语法：
- void assign(input_iterator first, input_iterator last); // 将区间[first, last)的元素赋值到当前vector
- void assign(size_type num, const TYPE & val); // 赋num个值为val的元素到vector中
- assign函数会清除掉为vector赋值以前的内容
案例

#include <iostream>
#include <vector> 
using namespace std;

int main() {
    int a[5] = {1, 2, 3, 4, 5};
    int b[2] = {1, 2};
    vector<int> v1(a, a + 5), v2(b, b + 2), v3;
    vector<int>::iterator iter;
    
    cout<<"v1 = ";
    for(iter = v1.begin(); iter != v1.end(); iter ++)
        cout<<*iter<<" ";
        cout<<endl;
        
    cout<<"v2 = ";
    for(iter = v2.begin(); iter != v2.end(); iter ++)
        cout<<*iter<<" ";
        cout<<endl;    
        
    v2 = v1;
    cout<<"v2 = ";
    for(iter = v2.begin(); iter != v2.end(); iter ++)
        cout<<*iter<<" ";
        cout<<endl; 
        
    v2.assign(v1.begin(), v1.end());
    cout<<"v2 = ";
    for(iter = v2.begin(); iter != v2.end(); iter ++)
        cout<<*iter<<" ";
        cout<<endl; 
        
    v3.assign(7, 3);
    cout<<"v3 = ";
    for(iter = v3.begin(); iter != v3.end(); iter ++)
        cout<<*iter<<" ";
        cout<<endl; 
        
    return 0;
}

  	v1 = 1 2 3 4 5 
  	v2 = 1 2 
  	v2 = 1 2 3 4 5 
  	v2 = 1 2 3 4 5 
  	v3 = 3 3 3 3 3 3 3

at 函数

语法：
- TYPE at(size_type loc); // 返回当前vector指定位置loc的元素的引用
- at()函数比[]运算符更安全，at()不会让你访问到vector内越界的元素
案例1

// 此段代码越界访问，可能导致危险结果
#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<int> v;
    v.assign(6, 6);
    for(int i = 0; i < 10; i ++)
        cout<<v[i]<<" ";
    cout<<endl;
    return 0;
}

  	6 6 6 6 6 6 135137 0 0 0

案例2

// 改良后的代码使用at(), 在越界的时候抛出异常out_of_range
#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<int> v;
    v.assign(6, 6);
    for(int i = 0; i < 10; i ++)
        cout<<v.at(i)<<" ";
    cout<<endl;
    return 0;
}

  	6 6 6 6 6 6 
  	
  	terminate called after throwing an instance of 'std::out_of_range'
  	  what():  vector::_M_range_check
  	/usercode/script.sh: line 62:    13 Aborted                 $output - < "/usercode/inputFile"

erase 函数

语法：
- iterator erase(iterator loc); //删除指定位置loc的元素
- iterator erase(iterator first, iterator last); // 删除区间[first, last)的所有元素
- erase函数返回值是指向删除的最后一个元素的下一位置的迭代器
案例

// 创建一个vec，置入字母表的前十个字符
#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<char> v;
    for(int i = 0; i < 10; ++ i)
        v.push_back(i + 65);
    int size = v.size();
    
    vector<char>::iterator startIterator;
    vector<char>::iterator tempIterator;
    
    for(int i = 0; i < size; i ++)
    {
        startIterator = v.begin();
        v.erase(startIterator);
        
        for(tempIterator = v.begin(); tempIterator != v.end(); tempIterator ++)
            cout<<*tempIterator;
        cout<<endl;
    }
    return 0;
}

  	BCDEFGHIJ
  	CDEFGHIJ
  	DEFGHIJ
  	EFGHIJ
  	FGHIJ
  	GHIJ
  	HIJ
  	IJ
  	J

get_allocator 函数
- 语法：
  - allocator_type get_allocator();
  - get_allocator() 函数返回当前vector的内存分配器.在STL里面一般不会new或者alloc来分配内存，而是通过一个allocator对象的相关方法来分配
- 案例
```
vector3(3, 1, v2.get_allocator());  // 把v2的内存分配器作为一个参数参与构造v3. 这样，他们两个用一个内存分配器.
```
c++中的allocator类

概述
- 它用于将内存的分配和对象的构造分离开来. 它分配的内存是原始的、未构造的.
```
allocator<string> alloc;  // 定义了一个可以分配string的allocator对象
auto const p = alloc.allocate(n);  // 分配n个未初始化的string内存，即为n个空string分配了内存，分配的内存是原始的、未构造的
```
allocator用法
- allocator<T> a // 定义了一个名为a的allocator对象，它可以为类型T的对象分配内存
- a.allocate(n) // 分配能保存n个类型为T的对象的内存
- a.deallocate(p, n) // 释放T*指针p地址开始的内存，这块内存保存了n个类型为T的对象，p必须是一个先前由allocate返回的指针，且n必须是p创建时所要求的大小，且在调用该函数之前必须销毁在这片内存上创建的对象，这是因为在创建的过程中我们分配的是最原始的内存，所以在释放内存的时候也只能严格释放这片最原始的内存
- a.construct(p, args) // p必须是一个类型为T*的指针，指向一片原始内存，arg将被传递给类型为T的构造函数，用来在p指向的原始内存上构建对象
- a.destory§ // p为T*类型的指针，用于对p指向的对象执行析构函数
详解
- allocate用于分配原始内存
  - 正如前面说到，allocate出来的内存是最原始的，未构造的内存. 它的construct成员函数接受一个指针和零个或多个额外的参数，在给定位置构造对象，额外的参数是用于初始化构造对象的
```
auto q = p;  // q指向最后构造的元素之后的位置
alloc.construct(q++);  // *q为空字符串
alloc.construct(q++, 10, 'c');  // *q为cccccccccc
alloc.construct(q++, "hi");  // *q为hi
```
  - 用完对象后，必须对这种构造的对象调用destory销毁，它接受一个指针，对指向的对象执行析构函数
```
while(q != p)
	alloc.destory(--q);
```
  循环开始处，q是指向最后构造的元素之后的一个位置，调用destory之前我们先对q进行递减操作，所以第一次调用destory销毁的是最后一个元素，依次执行销毁操作直到q和p相等. 我们只能对真正构造了的元素进行destory操作，一旦元素被销毁，就可以重新使用这部分内存来保存其他string或归还给系统，释放内存通过调用deallocate完成
```
alloc.deallocate(p, n)
```
  其中p不能为空，必须指向allocate分配的内存，而且大小参数n也必须与调用allocate分配内存时提供的大小参数相等

insert 函数

语法：
iterator insert(iterator loc, const TYPE & val); // 在指定位置loc前插入值为val的元素，返回指向这个元素的迭代器
void insert(iterator loc, size_type num, const TYPE & val); // 在指定位置loc前插入num个数值为val的元素
void insert(iterator loc, input_iterator first, input_iterator last); // 在指定位置loc前插入区间[first, last)的所有元素
案例

// 创建一个vec，置入字母表的前十个字符
#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<char> v;
    for(int i = 0; i < 10; ++ i)
        v.push_back(i + 65);
        
    // 插入4个C到vector中
    vector<char>::iterator theIterator = v.begin();
    v.insert(theIterator, 4, 'C');
    
    // 显示vector中的内容
    for(theIterator = v.begin(); theIterator != v.end(); theIterator ++)
        cout<<*theIterator;
    cout<<endl;
    return 0;
}

  	CCCCABCDEFGHIJ

max_size 函数
- 语法：
  - size_type max_size();
  - max_size() 函数返回当前vector所能容纳元素数量的最大值（注：包括可重新分配内存）

pop_back() 函数

语法：
- void pop_back(); // 删除当前vector最末的一个元素
案例

#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<char> v;
    for(int i = 0; i < 10; ++ i)
        v.push_back(i + 65);
        
   int size = v.size();
   vector<char>::iterator theIterator;
   for(int i = 0; i < size; i ++){
       v.pop_back();
    for(theIterator = v.begin(); theIterator != v.end(); theIterator ++)
        cout<<*theIterator;
    cout<<endl;
   }
    return 0;
}

  	ABCDEFGHI
  	ABCDEFGH
  	ABCDEFG
  	ABCDEF
  	ABCDE
  	ABCD
  	ABC
  	AB
  	A

rbegin 函数

语法：

reverse_iterator rbegin(); // 返回指向当前vector末尾的逆迭代器（实际指向末尾的下一位置，而其实际内容为末尾元素的值）
案例

#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<int> v;
    for(int i = 0; i <= 5; i ++)
        v.push_back(i);
    vector<int>::reverse_iterator pos;
    pos = v.rbegin();
    for(int i = 0; i <= 5; i ++)
    {
        cout<<*pos<<" ";
        pos++;
    }
    return 0;
}

  	5 4 3 2 1 0

rend 函数

语法：

reverse_iterator rend(); // 返回指向当前vector起始位置的逆迭代器
案例

#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<int> v;
    for(int i = 0; i <= 5; i ++)
        v.push_back(i);
    vector<int>::reverse_iterator pos;
    pos = v.rend();
    for(int i = 0; i <= 5; i ++)
    {
        pos--;
        cout<<*pos<<" ";
    }
    return 0;
}

  	0 1 2 3 4 5

reserve 函数
- 语法：
  - void reserve(size_type size); // 设置为当前vector预留至少共容纳size个元素的空间（注：实际空间可能大于size）
resize 函数
- 语法：
  - void resize(size_type size, TYPE val); // 改变当前vector的大小为size，且对新创建的元素赋值val

resize 与 reserve 的区别

reserve 是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当加入新的元素时，需要用push_back()/insert() 函数
resize 是改变容器的大小，并且创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的对象时，用operator[]操作符，或者用迭代器来引用元素对象，
resize就是重新分配大小，reserve就是预留一定的空间
附：reverse 与 resize 接口源码

void resize(size_type new_size){
	resize(new_size, T());}
void resize(size_type new_size, const & x){
	if(new_size < oldsize)
		erase(oldbegin + new_size, oldend);  // erase区间范围以外的数据，确保区间以外的数据无效
	else
		insert(oldend, new size - oldsize, x);  // 填补区间范围内空缺的数据，确保区间内的数据有效

案例

#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<int> v;
    
    for(int i = 1; i <= 3; i ++)
        v.push_back(i);
        
    v.resize(5, 8);   //多出的两个空间都初始化为8
    for(int i = 0; i < v.size(); i ++)  // resize 与 reverse并不会删除原先的元素以释放空间
        cout<<v[i];
    cout<<endl;
    
    v.reserve(7);  // 新元素还没有构造
    for(int i = 0; i < 7; i ++)
        cout<<v[i]<<" ";  // 当i > 4。此时不能用[]访问元素
    cout<<endl;
    
    cout<<v.size()<<endl;
    cout<<v.capacity()<<endl;
    return 0;

}

  	12388
  	1 2 3 8 8 0 0 
  	5
  	7

size 函数
- 语法：
  - size_type size(); // 返回当前vector所容纳元素的数量

swap 函数

语法：
- void swap(vector & from); // 交换当前vector与vector from的元素
案例

#include <iostream>
#include <vector> 
using namespace std;

int main() {
    vector<int> v1, v2;
    
    for(int i = 1; i <= 3; i ++){
        v1.push_back(i);
        v2.push_back(i);
    }
    
    v2.push_back(4);
    v2.push_back(5);
    v1.swap(v2);
    
    for(int j = 0; j < v1.size(); j ++)
        cout<<v1[j]<<" ";
    cout<<endl;
    
    for(int k = 0; k < v2.size(); k ++)
        cout<<v2[k]<<" ";
    cout<<endl;
    
    return 0;

}

  	1 2 3 4 5 
  	1 2 3

vector 用法

vector 基本用法案例

	#include <iostream>
	#include <vector> 
	using namespace std;
	
	template<class T>
	void PrintVector(const vector <T> & v)
	{
	    // 用于输出vector容器的全部元素的函数模板
	    typename vector <T>::const_iterator i;  // const_iterator 类型的迭代器只能用于读不能进行重写
	    // typename 用来说明 vector<T>::const_iterator 是一个类型，在VS中不写也可以
	    for(i = v.begin(); i != v.end(); i ++)
	        cout<<*i<<" ";
	    cout<<endl;
	}
	
	int main()
	{
	    int a[5] = {1, 2, 3, 4, 5};
	    vector<int> v(a, a + 5);  // 将数组a的内容放入v
	    cout<<"1. "<<v.end() - v.begin()<<endl;  // 两个随机迭代器可以相减
	    cout<<"2. "; PrintVector(v);
	    v.insert(v.begin() + 2, 13);  // 在 begin() + 2 位置插入13
	    cout<<"3. "; PrintVector(v);
	    v.erase(v.begin() + 2);  // 删除位于 begin() + 2 位置的元素
	    cout<<"4. "; PrintVector(v);
	    vector<int> v2(4, 100);  // v2 有4个元素，都是100
	    v2.insert(v2.begin(), v.begin() + 1, v.begin() + 3);  // 将v的一段插入v2开头
	    cout<<"5. v2: "; PrintVector(v2);
	    v.erase(v.begin() + 1, v.begin() + 3);  // 删除v上的一个区间，即[2, 3)
	    cout<<"6. "; PrintVector(v);
	    
	    return 0;
	}

	1. 5
	2. 1 2 3 4 5 
	3. 1 2 13 3 4 5 
	4. 1 2 3 4 5 
	5. v2: 2 3 100 100 100 100 
	6. 1 4 5

vector 还可以嵌套以形成可变长的二维数组

	#include <iostream>
	#include <vector> 
	using namespace std;
	
	int main()
	{
	    vector<vector<int> > v(3);  // v3有三个元素，每个元素都是vector容器
	    for(int i = 0; i < v.size(); i ++)
	        for(int j = 0; j < 4; j ++)
	            v[i].push_back(j);
	        
	    for(int i = 0; i < v.size(); i ++){
	        for(int j = 0; j < v[i].size(); j ++)
	            cout<<v[i][j]<<" ";
	        cout<<endl;
	    }
	    return 0;
	}

	0 1 2 3 
	0 1 2 3 
	0 1 2 3 

- 注：
	- `vector<vector<int> > v(3);` 定义了一个 vector 容器，该容器中的每个元素都是一个 vector<int> 容器，即可以认为，v是一个二维数组，一共三行，每行都是一个可变长的一维数组 
	- 在 Dev C++ 中，上面写法中 int 后面的两个`>`之间需要有空格，否则有的编译器会把它们当作`>>`运算符，编译会出错

vector 的元素不仅仅可以是int，double，string，还可以是结构体，但是要注意：结构体定义为全局的，否则会出错

案例

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector> 
using namespace std;

typedef struct rect{
    int id;
    int length;
    int width;
    
    // 对于向量元素是结构体的。可在结构体内部定义比较函数，下面按照id，length，width升序排序
    bool operator < (const rect & a) const
    {
        if(id != a.id)
            return id < a.id;
        else
        {
            if(length != a.length)
                return length < a.length;
            else
                return width < a.width;
        }
    }
}Rect;

int main() {
    vector<Rect> vec;
    Rect rect;
    rect.id = 1;
    rect.length = 2;
    rect.width = 3;
    vec.push_back(rect);
    vector<Rect>::iterator it = vec.begin();
    cout<<(*it).id<<" "<<(*it).length<<" "<<(*it).width<<endl;
    
    return 0;
}

  	1 2 3

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

C++ Vector 详解

c++ vector

简介

函数列表

函数详解

c++中的allocator类

概述

allocator用法

详解

vector 用法

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

C++ Vector 详解

c++ vector

简介

函数列表

函数详解

c++中的allocator类

概述

allocator用法

详解

vector 用法

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品