精华内容
下载资源
问答
  • vector常被称为容器(container)。 为了使用vector,需要: #include <vector> using std::vector; vector是一个类模版(class template)。C++有函数模版和类模版。模版本身不是函数或类,必须通过指定 类型让...
  • c++从txt文件中读取数据,原本是为了读取txt文件中点云的三位坐标。每行的内容为一个空间点,存入vector中;所有的点(行)又存在一个vector中。其数据结构为vector<vector<float>> CloudPoints
  • 我们把 vector 称为容器,是因为它可以包含其他对象 。 一个容器中的所有对象都必须是同一种类型的 。 vector对象的定义和初始化 同样的,使用前,导入头文件#include <vector> 可以使用using声明:using std::...
  • vector容器一般被用作创建动态数组,动态数组就像Python中的list结构一样,可以比普通数组拥有更丰富操作方法,下面就为大家整理了一些最常用的操作:
  • vector作为STL提供的标准容器之一,是经常要使用的,有很重要的地位,并且使用起来也是灰常方便。vector又被称为向量,vector可以形象的描述为长度可以动态改变的数组,功能和数组较为相似
  • 有关用法示例,请参见test_vector.m中的测试。
  • C++ vector容器的常用用法

    千次阅读 2020-03-01 13:13:13
    vector可以说是一个动态数组,它可以存储任何类型的数据,包括类! 使用vector需包含头文件#include< vector >. 定义 一、不带参数 // 定义了一个int类型的容器 vector<int> v1; // 定义了一个double...

    vector可以说是一个动态数组,它可以存储任何类型的数据,包括类!

    使用vector需包含头文件#include< vector >.

    定义

    一、不带参数

    // 定义了一个int类型的容器
    vector<int> v1;
    
    // 定义了一个double类型的容器
    vector<double> v2;
    

    注意事项:
    容器可以使用数组方式获取它的值 和 给它赋值,但是得注意越界!

    例如:
    不可以使用数组方式给他赋值,因为容器并没有给他分配内容空间:

    vector<int> v1;
    // 不可以使用数组方式给他赋值,因为容器并没有给他分配内容空间
    v1[0] = 1;	// error
    
    
    // 可以使用数组方式给他赋值:
    vector<int> v2(10);
    v2[0] = 1;	// 正确
    
    v2[11] = 11; // 错误,越界
    

    二、带参数

    1. 定义了一个int类型的容器,定义时指定给他分配十个元素的空间
    // 定义了一个int类型的容器,定义时指定给他分配十个元素的空间
    vector<int> v1(10);
    

    默认10个元素都是零值。

    1. 定义时指定10个元素的内存,同时给所有元素赋值666
    vector<int> v3(10, 666);
    
    1. 定义时可以使用其他容器来初始化自己
    vector<int> v1(5, 666);
    // 定义时可以使用其他容器来初始化自己
    vector<int> v2(v1);	// v1 和 v2 相等
    
    1. // 也可以使用 返回迭代器 的方式将一个容器的元素全都赋值给自己
    vector<int> v1(5, 666);
    
    vector<int> v2(v1.begin(), v1.end());
    
    1. begin 和 end 返回来的就是一个指针迭代器,所以可以进行加减操作,指向其他元素的位置
    vector<int> v1(5, 666);
    
    // 将v1的元素从第三个元素到最后的元素赋值给v2
    vector<int> v2(v1.begin() + 2, v1.end());
    
    1. 可以使用数组来初始化容器
    int Array[5] = {1, 2, 3, 4, 5};
    // 将数组元素1,2,3,4给容器赋初值
    vector<int> v1 = (Array, Array+3);
    

    size 获取容器的元素个数

    size()

    vector<int> v1;
    
    v1.size();
    

    capacity 获取容器的大小

    capacity()

    vector<int> v1;
    
    v1.capacity();
    

    begin 获取容器第一个元素的迭代器

    begin()

    vector<int> v1(10, 666);
    
    v1.begin();
    

    end 指向容器最后一个元素的下一个位置的迭代器

    end()

    vector<int> v1(10, 666);
    
    v1.end();
    

    assign 赋值玩法

    1. 第一种玩法 会改变原来vector中的元素内存大小

    将v1元素修改为5个,并且赋值888

    vector<int> v1(10);
    
    v1.assign(5, 888);	// 打印结果5个888
    
    1. 第二种玩法,使用迭代器赋值

    将容器v2的10个1赋值给v1,使得v1和v2相等

    vector<int> v1(5);
    vector<int> v2(10, 1);
    
    v1.assign(v2.begin(), v2.end());	// 打印结果10个1
    
    1. 第三种玩法,使用指针赋值

    将数组的所有元素都赋值给v1

    int Array[5] = { 9, 8, 7, 6, 5 };
    vector<int> v1;
    
    v1.assign(Array, Array + 4);	// 打印结果9,8,7,6,5
    
    1. 第四种玩法,使用赋值运算符重载

    将v1所有元素赋值给v2

    vector<int> v1(10, 1);
    vector<int> v2;
    
    v2 = v1;	// 打印结果10个1
    

    resize 将容器缩小和变大

    一、把容器元素缩小

    vector<int> v1(10);
    
    v1.resize(5);	// 缩小长度为5
    

    二、把容器扩大时,并给增加的元素赋值

    vector<int> v1(5);
    
    v1.resize(8, 111);	// 扩充v1容器的大小为8,后续新增加的使用111赋值
    

    三、把容器扩大,不给增加的元素赋值

    vector<int> v1(5);
    
    v1.resize(15);
    

    empty 判断容器是否为空

    为空返回true,为假返回false

    vector<int> v1(5);
    
    if (v1.empty() == NULL) {
    	cout << "v1为空!" << endl;
    }
    

    push_back 尾部添加一个元素

    vector<int> v1;
    
    v1.push_back(1);	// 在尾部增加要给1
    

    pop_back 尾部删除一个元素

    vector<int> v1(10);
    
    v1.pop_back();	// 在尾部删除一个元素
    

    at 和数组使用方式差不多

    给第一个元素赋值1

    vector<int> v1(10);
    
    v1.at(0) = 1; 
    

    打印输出容器里的所有元素

    cout << "v1的所有元素:";
    for (int i = 0; i < v1.size(); i++) {
    	cout << v1.at(i) << ", ";
    }
    

    front 获取容器的第一个元素

    vector<int> v1(10);
    
    v1.front();
    
    // 也可以使用他们赋值
    v1.front() = 111;	// 给第一个元素赋值111
    

    back 获取容器的最后一个元素

    vector<int> v1(10);
    
    v1.back();
    
    // 也可以使用他们赋值
    v1.back() = 222;	// 给最后一个元素赋值222
    

    insert 元素的插入

    vector<int> v1(10);
    
    // 往第一个元素的位置插入一个5
    v1.insert(v1.begin(), 5);
    
    
    // 从第三个元素位置开始插入5个222
    v1.insert(v1.begin() + 2, 5, 222);
    
    
    vector<int> v2(3, 111);
    // 从第二个元素开始插入v2的所有值
    v1.insert(v1.begin() + 1, v2.begin(), v2.end());
    

    erase 与 clear 元素删除

    vector<int> v1(10);
    
    // 删除第一个元素
    v1.erase(v1.begin());
    
    // 删除第一个到第三个元素
    v1.erase(v1.begin(), v1.begin() + 3);
    
    // 删除全部元素
    v1.clear();
    

    汇总代码:

    #include <iostream>
    #include <Windows.h>
    #include <vector>
    
    using namespace std;
    
    // 不带参数的
    void text1(void) {
    	vector<int> v1;
    
    	cout << "v1的元素个数:";
    	cout << v1.size() << endl;
    
    	cout << "v1容器的大小:";
    	cout << v1.capacity() << endl;
    
    	v1.push_back(1);
    	v1.push_back(2);
    
    	cout << endl << "v1插入两个元素后:" << endl;
    	cout << "v1的元素个数:";
    	cout << v1.size() << endl;
    
    	cout << "v1容器的大小:";
    	cout << v1.capacity() << endl;
    
    	/*
    	注意:
    		不可以使用数组方式给他赋值,因为容器并没有给他分配内容空间:
    			vector<int> v;
    			v[0] = 1;	// error
    	*/
    }
    
    // 带参数的
    void text2(void) {
    	vector<int> v2(10);	// 定义时指定给他分配十个元素的空间
    
    	cout << "v2的元素个数:";
    	cout << v2.size() << endl;
    
    	cout << "v2容器的大小:";
    	cout << v2.capacity() << endl;
    
    	// 里面默认的值全为零
    	cout << "v2里面的元素为:" << endl;
    	vector<int>::iterator it = v2.begin();
    	for (; it != v2.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    
    	/*
    	可以使用数组方式给他赋值:
    		vector<int> v(10);
    		v[0] = 1;	// 正确
    	*/
    	v2[0] = 1;	// 正确
    	v2[1] = 2;
    	cout << "v2里面的元素为:" << endl;
    	it = v2.begin();
    	for (; it != v2.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    	/************************************************************************************************/
    
    	vector<int> v3(10, 666);	// 定义时指定10个元素的内存,同时给所有元素赋值666
    	cout << "v3里面的元素为:" << endl;
    	it = v3.begin();
    	for (; it != v3.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    	/************************************************************************************************/
    
    	vector<int> v4(v3);	// 定义时可以使用其他容器来初始化自己
    	cout << "v4里面的元素为:" << endl;
    	it = v4.begin();
    	for (; it != v4.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    	/************************************************************************************************/
    
    	vector<int> v5(v2.begin(), v2.end());	// 也可以使用该种方式将v2的元素全都赋值给自己
    	cout << "v5里面的元素为:" << endl;
    	it = v5.begin();
    	for (; it != v5.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    	/************************************************************************************************/
    
    	vector<int> v6(v2.begin() + 1, v2.end());	// begin返回来的就是一个指针迭代器,所以可以进行加1操作,指向下一个元素
    	cout << "v6里面的元素为:" << endl;
    	it = v6.begin();
    	for (; it != v6.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    	/************************************************************************************************/
    
    	int text[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    	vector<int> v7(text, text + 5);	// 可以使用这种方式获取数组的值初始化自己(1,2,3,4,5)
    	cout << "v7里面的元素为:" << endl;
    	it = v7.begin();
    	for (; it != v7.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    }
    
    // vector容器赋值assign玩法
    void assign(void) {
    	vector<int> v1(5);
    
    	// 第一种玩法	会改变原来vector中的元素内存大小
    	v1.assign(3, 8);
    	cout << "玩法一:" << endl;
    	vector<int>::iterator it = v1.begin();
    	for (; it != v1.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    
    	// 第二种玩法,使用迭代器赋值
    	vector<int> v2(10, 1);
    	v1.assign(v2.begin(), v2.end());
    	cout << "玩法二:" << endl;
    	it = v1.begin();
    	for (; it != v1.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    
    	// 第三种玩法,使用指针赋值
    	int Array[5] = { 9, 8, 7, 6, 5 };
    	v1.assign(Array, Array + 2);
    	cout << "玩法三:" << endl;
    	it = v1.begin();
    	for (; it != v1.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    
    
    	// 第四种玩法,使用赋值运算符重载
    	vector<int> v3;
    	v3 = v1;
    	cout << "玩法四:" << endl;
    	it = v3.begin();
    	for (; it != v3.end(); it++) {
    		cout << *it << ", ";
    	}
    	cout << endl;
    }
    
    // resize将容器缩小和变大 与 empty判断容器是否为空
    void text3(void) {
    	vector<int> v1(10);
    	
    	// 一、把容器元素缩小
    	cout << "v1的元素个数:" << v1.size() << endl;
    	v1.resize(5);	// 调整他的元素个数为5
    	cout << "v1的元素个数:" << v1.size() << endl;
    
    
    
    	// 二、把容器扩大时,并给增加的元素赋值
    	v1.resize(8, 111);	// 扩充v1容器的大小为8,后续新增加的使用111赋值
    	cout << "v1的元素个数:" << v1.size() << endl;
    	cout << "v1的所有元素:";
    	for (int i = 0; i < v1.size(); i++) {
    		cout << v1[i] << ", ";
    	}
    	cout << endl;
    
    
    
    	// 三、把容器扩大,不给增加的元素赋值
    	v1.resize(15);
    	cout << "v1的元素个数:" << v1.size() << endl;
    	cout << "v1的所有元素:";
    	for (int i = 0; i < v1.size(); i++) {
    		cout << v1[i] << ", ";
    	}
    	cout << endl;
    
    
    
    
    	cout << endl << endl << "---empty---" << endl;
    	// 判断容器是否为空
    	vector<int> v2;
    
    	if (v2.empty()) {
    		cout << "v2为空!" << endl;
    	}
    }
    
    // 尾部添加和删除
    void text4(void) {
    	vector<int> v1;
    
    	cout << "v1的元素个数:" << v1.size() << endl;
    
    	// 尾部添加一个元素
    	v1.push_back(666);
    	cout << "v1的元素个数:" << v1.size() << endl;
    
    	// 尾部删除一个元素
    	v1.pop_back();
    	cout << "v1的元素个数:" << v1.size() << endl;
    }
    
    // at 与 front 与 back
    void text5(void) {
    	vector<int> v1(10);
    
    	// 可以使用at修改容器里面的值,返回的是一个引用
    	v1.at(0) = 888;
    	// 和数组方式差不多
    	v1[1] = 999;
    
    	// 输出
    	cout << "v1的所有元素:";
    	for (int i = 0; i < v1.size(); i++) {
    		cout << v1[i] << ", ";
    	}
    	cout << endl;
    
    	// 也可以使用at输出
    	cout << "v1的所有元素:";
    	for (int i = 0; i < v1.size(); i++) {
    		cout << v1.at(i) << ", ";
    	}
    	cout << endl;
    
    	// 他们返回的都是一个引用
    	cout << "第一个元素:" << v1.front() << endl;
    	cout << "最后一个元素:" << v1.back() << endl;
    
    	// 也可以使用他们赋值
    	v1.front() = 111;
    	v1.back() = 222;
    	cout << "v1的所有元素:";
    	for (int i = 0; i < v1.size(); i++) {
    		cout << v1.at(i) << ", ";
    	}
    	cout << endl;
    }
    
    // insert 元素的插入
    void text6(void) {
    	vector<int> v1(10);
    
    	// 往第一个元素的位置插入一个5
    	v1.insert(v1.begin(), 5);
    
    	// 从第三个元素位置开始插入5个222
    	v1.insert(v1.begin() + 2, 5, 222);
    
    	vector<int> v2(3, 111);
    	// 从第二个元素开始插入v2的所有值
    	v1.insert(v1.begin() + 1, v2.begin(), v2.end());
    
    	cout << "v1的所有元素:";
    	for (int i = 0; i < v1.size(); i++) {
    		cout << v1.at(i) << ", ";
    	}
    	cout << endl;
    }
    
    // 元素删除
    void text7(void) {
    	vector<int> v1(10);
    
    	// 删除第一个元素
    	v1.erase(v1.begin());
    
    	// 删除第一个到第三个元素
    	v1.erase(v1.begin(), v1.begin() + 3);
    
    	// 删除全部元素
    	v1.clear();
    }
    
    int main(void) {
    	//text1();
    
    	//text2();
    
    	//assign();
    
    	//text3();
    
    	//text4();
    
    	//text5();
    
    	//text6();
    
    	//text7();
    
    	system("pause");
    	return 0;
    }
    

    总结:

    vector容器常用的函数已经列出来了,剩下还有很多个不常用的,就不说明了,需要用到的话,再另行百度吧!

    展开全文
  • 本文实例为大家分享了C++ vector容器 实现贪吃蛇,供大家参考,具体内容如下 使用vector容器实现贪吃蛇简化了很多繁琐操作,且相比之前我的代码已经做到了尽量的简洁 技术环节: 编译环境:windows VS2019 需求: ...
  • c++中vector容器详解

    千次阅读 2019-03-11 21:24:36
    vector是表示可变大小数组的序列容器。 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且...

    vector是表示可变大小数组的序列容器。
    就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。本质讲,vector使用动态分配数组来存储它的元素。当新元素插入时候,这个数组需要被重新分配大小为了增加存储空间。其做法是,分配一个新的数组,然后将全部元素移到这个数组。就时间而言,这是一个相对代价高的任务,因为每当一个新的元素加入到容器的时候,vector并不会每次都重新分配大小。vector分配空间策略:vector会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何,重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。因此,vector占用了更多的存储空间,为了获得管理存储空间的能力,并且以一种有效的方式动态增长。与其它动态序列容器相比(deques, lists and forward_lists), vector在访问元素的时候更加高效,在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作,效率更低。比起lists和forward_lists统一的迭代器和引用更好。
    1.vector声明及初始化

    vector<int> vec;        //声明一个int型向量
    vector<int> vec(5);     //声明一个初始大小为5的int向量
    vector<int> vec(10, 1); //声明一个初始大小为10且值都是1的向量
    vector<int> vec(tmp);   //声明并用tmp向量初始化vec向量
    vector<int> tmp(vec.begin(), vec.begin() + 3);  //用向量vec的第0个到第2个值初始化tmp
    int arr[5] = {1, 2, 3, 4, 5};   
    vector<int> vec(arr, arr + 5);      //将arr数组的元素用于初始化vec向量
    //说明:当然不包括arr[4]元素,末尾指针都是指结束元素的下一个元素,
    //这个主要是为了和vec.end()指针统一。
    vector<int> vec(&arr[1], &arr[4]); //将arr[1]~arr[4]范围内的元素作为vec的初始值
    

    2.vector基本操作
    (1). 容量

    1. 向量大小: vec.size();
    2. 向量最大容量: vec.max_size();
    3. 更改向量大小: vec.resize();
    4. 向量真实大小: vec.capacity();
    5. 向量判空: vec.empty();
      (2). 修改
    6. 多个元素赋值: vec.assign(); //类似于初始化时用数组进行赋值
    7. 末尾添加元素: vec.push_back();
    8. 末尾删除元素: vec.pop_back();
    9. 任意位置插入元素: vec.insert();
    10. 任意位置删除元素: vec.erase();
    11. 交换两个向量的元素: vec.swap();
    12. 清空向量元素: vec.clear();
      (3)迭代器
    13. 开始指针:vec.begin();
    14. 末尾指针:vec.end(); //指向最后一个元素的下一个位置
      (4)元素的访问
    15. 下标访问: vec[1]; //并不会检查是否越界
    16. at方法访问: vec.at(1);//以上两者的区别就是at会检查是否越界,是则抛出out of range异常
    17. 访问第一个元素: vec.front();
    18. 访问最后一个元素: vec.back();
      (4)算法
      遍历元素
    vector<int>::iterator it;
    for (it = vec.begin(); it != vec.end(); it++)
        cout << *it << endl;
    //或者
    for (size_t i = 0; i < vec.size(); i++) {
        cout << vec.at(i) << endl;
    }
    

    元素翻转

    #include <algorithm>
    reverse(vec.begin(), vec.end());
    

    元素排序

    #include <algorithm>
    sort(vec.begin(), vec.end()); //采用的是从小到大的排序
    //如果想从大到小排序,可以采用上面反转函数,也可以采用下面方法:
    bool Comp(const int& a, const int& b) {
        return a > b;
    }
    sort(vec.begin(), vec.end(), Comp);
    

    常用操作实例

    #include "iostream"
    using namespace std;
    #include "vector"
    #include "algorithm"
    
    //数组元素的 添加和删除
    void add_erase()
    {
    	vector<int> Vector;
    	Vector.push_back(1);
    	Vector.push_back(3);
    	Vector.push_back(5);
    	cout << "头部元素" << Vector.front() << endl;//头部元素
    	cout << "尾部元素" << Vector.back() << endl;// 尾部元素
    	//修改 头部元素
    	//函数返回值当左值 应该返回一个引用
    	Vector.front() = 11;
    	Vector.back() = 55;
    	cout << "头部元素" << Vector.front() << endl;//头部元素
    	cout << "尾部元素" << Vector.back() << endl;// 尾部元素
    
    	while (Vector.size() > 0)
    	{
    		Vector.pop_back(); //删除尾部元素
    	}
    }
    //遍历====》数组方式遍历,迭代器遍历
    void cheak()
    {
    	vector<int> Vector(10);//容器vector做数组存储数据时,应该提前把内存准备好
    	for (int i = 0; i < 10; i++)
    	{
    		Vector[i] = i;
    	}
    	for (int i = 0; i < 10; i++)
    	{
    		cout << Vector[i] << "  ";
    	}
    }
    //迭代器遍历
    void Cheak()
    {
    	vector<int> Vector(10);//容器vector做数组存储数据时,应该提前把内存准备好
    	for (int i = 0; i < 10; i++)
    	{
    		Vector[i] = i;
    	}
    	cout << "正向迭代:" ;
    	for (vector<int>::iterator it = Vector.begin(); it != Vector.end(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    	cout << "反向迭代:";
    	for (vector<int>::reverse_iterator rit = Vector.rbegin(); rit != Vector.rend(); rit++)//反向迭代器的开始和结束函数名变为rbegin()和rend()
    	{
    		cout << *rit << " ";
    	}
    	cout << endl;
    }
    void print(vector<int> &Vector)
    {
    	for (vector<int>::iterator it = Vector.begin(); it != Vector.end(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    //迭代器的删除erase
    void delete_()
    {
    	vector<int> Vector(10);//容器vector做数组存储数据时,应该提前把内存准备好
    	for (int i = 0; i < 10; i++)
    	{
    		Vector[i] = i;
    	}
    	//区间删除
    	Vector.erase(Vector.begin(), Vector.begin() + 3);
    	print(Vector);
    	//根据元素的位置 指定位置删除
    	Vector.erase(Vector.begin()+2);//在头部之后的第二个位置删除一个元素
    	print(Vector);
    	//根据元素的值
    	for (vector<int>::iterator it = Vector.begin(); it != Vector.end(); it++)
    	{
    		if (*it == 8)
    		{
    			it = Vector.erase(it); //当删除迭代器所指向的元素的时候,erase删除函数会让it自动下移动.并且vector容器的erase会返回一个迭代器
    		}
    	}
    	print(Vector);
    	//插入元素
    	Vector.insert(Vector.begin(),100);//在开头插入元素
    	Vector.insert(Vector.end(), 200);//在末尾插入元素
    	print(Vector);
    }
    
    展开全文
  • 在c++中,vector是一个十分有用的容器,下面通过本文给大家介绍C++中vector容器使用详细说明,具体介绍如下所示 1. 在C++中的详细说明 vector是C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构...
  • vector容器用法详解

    千次阅读 2019-05-05 10:17:44
    类模板std::vector 容器属性 函数总览: Iterators(迭代器): begin:将迭代器返回到开头。 end:将迭代器返回到结束。 rbegin:返回反向迭代器以反向开始。 rend:将反向迭代器返回到反向结束。 Capacity...

    目录

     

    类模板std::vector

    容器属性

    函数总览:

    Iterators(迭代器):

    begin:将迭代器返回到开头。

    end:将迭代器返回到结束。

    rbegin:返回反向迭代器以反向开始。

    rend:将反向迭代器返回到反向结束。

    Capacity(容量):

    max_size:迭返回代器可以作为内容保存的最大元素数。

    size:返回向量中的元素数。

    resize:改变容器大小

    capacity[kə'pæsəti]:返回分配的存储容量大小

    reserve:请求更改容量

    empty:检测向量是否为空

    Element access(元素访问):

    operator[]:访问元素

    at:访问元素

    front:访问第一个元素

    back:访问最后一个元素

    Modifiers(编辑):

    assign:分配向量内容

    push_back:在最后添加元素

    pop_back:删除最后元素

    insert:插入元素

    erase[ɪ'reɪz]:擦除元素

    swap:交换元素

    clear:清空元素

    函数详解:

    Iterators(迭代器):

    begin: -->end: -->rbegin: -->rend:

    Capacity(容量):

    max_size: -->size: -->rsize: -->capacity: -->reserve: -->empty:

    Element access(元素访问):

    operator[]: -->at: -->front: -->back:

    Modifiers(编辑):

    assign: -->push_back: -->pop_back: -->insert: -->erase: -->swap: -->clear:


    类模板std::vector

    template <class T,class Alloc = allocator <T >> class vector; //通用模板

    容器属性

    序列

    序列容器中的元素按严格的线性顺序排序。各个元素按其顺序访问它们的位置。

    动态数组

    允许直接访问序列中的任何元素,甚至通过指针算术,并在序列的末尾提供相对快速的元素添加/删除。

    分配感知器

    容器使用allocator对象来动态处理其存储需求。

    向量(vector)

    向量是表示可以改变大小的数组的序列容器。

    就像数组一样,向量使用连续的存储位置作为元素,这意味着它们的元素也可以使用常量指向其元素的偏移来访问,并且与数组一样有效。但与数组不同,它们的大小可以动态变化,其存储由容器自动处理。

    在内部,向量使用动态分配的数组来存储它们的元素。可能需要重新分配此数组,以便在插入新元素时增大大小,这意味着分配新数组并将所有元素移动到该数组。就处理时间而言,这是相对昂贵的任务,因此,每次将元素添加到容器时,向量不会重新分配。

    相反,向量容器可以分配一些额外的存储以适应可能的增长,因此容器可以具有大于包含其元素(即,其大小)严格需要的存储的实际容量。库可以实现不同的增长策略以在内存使用和重新分配之间取得平衡,但无论如何,重新分配只应以对数增长的大小间隔发生,以便在向量末尾插入单个元素可以提供摊销的常量时间复杂性(见push_back)。

    因此,与数组相比,向量消耗更多内存以换取管理存储和以有效方式动态增长的能力。

    与其他动态序列容器(dequse,lists和forward_lists)相比,向量非常有效地访问其元素(就像数组一样)并且相对有效地从其末尾添加或删除元素。对于涉及在末尾以外的位置插入或删除元素的操作,它们的性能比其他位置差,并且与列表和forward_lists相比具有更少的一致的迭代器和引用。


    函数总览:

    member function:

    Iterators(迭代器):

    注:迭代器(iterator)是一种对象,它能够用来遍历标准模板库容器中的部分或全部元素,每个迭代器对象代表容器中的确定的地址。

    begin:将迭代器返回到开头。

    end:将迭代器返回到结束。

    rbegin:返回反向迭代器以反向开始。

    rend:将反向迭代器返回到反向结束。

     

    Capacity(容量):

    max_size:迭返回代器可以作为内容保存的最大元素数。

    size:返回向量中的元素数。

    resize:改变容器大小

    capacity[kə'pæsəti]:返回分配的存储容量大小

    reserve:请求更改容量

    empty:检测向量是否为空

     

    Element access(元素访问):

    operator[]:访问元素

    at:访问元素

    front:访问第一个元素

    back:访问最后一个元素

     

    Modifiers(编辑):

    assign:分配向量内容

    push_back:在最后添加元素

    pop_back:删除最后元素

    insert:插入元素

    erase[ɪ'reɪz]:擦除元素

    swap:交换元素

    clear:清空元素


    函数详解:

    Iterators(迭代器):

    begin:

    将迭代器返回到开头。返回指向向量中第一个元素的迭代器。

    iterator begin();

    请注意,与成员vector :: front不同,它返回对第一个元素的引用,此函数返回指向它的随机访问迭代器。

    /*======================================
    函数操作:begin()
    函数参数:无
    函数返回:指向vector 中第一个元素iterator
    ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myvector;
        for(int i = 1; i <= 5; i++)
            myvector.push_back(i);
        vector<int>::iterator it;    //it是迭代器指针类型,对vector 迭代器指针进行++,相当于对数组指针进行++操作。
        std::cout << "myvector contains:";
        for(it = myvector.begin(); it != myvector.end(); it++)
            cout<<*it<<" ";
        cout<<endl;
        return 0;
    }
    /*=======================================
    函数输出:myvector contains:1 2 3 4 5 
    =======================================*/

    end:

    将迭代器返回到结束.返回一个迭代器,引用向量容器中的past-the-end元素(一个不存在的元素)。

    iterator end();

    后端元素是向量中最后一个元素后面的理论元素(此处可以理解为:向量中最后一个数据的下一个数据地址,如果这个位置曾经存储过数据,则*object.end()返回该数据的值)。它不指向任何元素,因此不应取消引用。因为标准库的函数使用的范围不包括其闭合迭代器指向的元素,所以此函数通常与vector :: begin结合使用以指定包含容器中所有元素的范围。 如果容器为空,则此函数返回与vector :: begin相同的值。

    /*======================================
     函数操作:end()
     函数形参:无
     函数返回:指向vector 中最后一个元素的下一个
              元素的iterator
     注意:[myvector.begin(), myvector.end())
           表示左闭右开区间
     ======================================*/
    #include <iostream>
    #include <vector>
    
    int main()
    {
        std::vector<int> myvector;
        for(int i = 1; i <= 5; i++)
            myvector.push_back(i);
        std::cout << "myvector contains:";
        for(std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); it++)
            std::cout << *it << " ";
        std::cout << std::endl;
        return 0;
    }
    /*=======================================
    函数输出:myvector contains:1 2 3 4 5 
    =======================================*/

    注:迭代器不能等于 end();比如 it = myvector.end(); 运行结果如下图,end()是一个错误的指针

    rbegin:

    返回指向向量中最后一个元素的反向迭代器(即,它的反向开始)。

    reverse_iterator rbegin();//reverse_iterator是双向迭代器类型。

    反向迭代器向后迭代:增加它们将它们移向容器的开头。rbegin指向成员端指向的元素之前的元素。请注意,与成员vector :: back不同,它返回对此相同元素的引用,此函数返回反向随机访问迭代器。

    /*======================================
     函数操作:rbegin()
     函数形参:无
     函数返回:指向vector 中最后一个元素的iterator
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myvector;
        for(int i = 1; i <= 5; i++)
            myvector.push_back(i);
        cout << "myvector contains:";
        vector<int>::reverse_iterator it;
        for(it = myvector.rbegin(); it != myvector.rend(); it++)
            cout << *it << " ";
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contains:5 4 3 2 1
     =======================================*/

    rend:

    将反向迭代器返回到反向结束。

    reverse_iterator rbegin();

    返回一个反向迭代器,指向向量中第一个元素之前的理论元素(被认为是它的反向结束)。vector::rbegin和vector::rend之间的范围包含了向量的所有元素(按相反的顺序)。

    注:程序同上,此处省略


    Capacity(容量):

    max_size:

    返回最大尺寸

    size_type max_size() const;

    返回向量可容纳的最大元素数。由于已知的系统或库实现限制,这是容器能够达到的最大可能大小,但是容器并不能保证能够达到这个大小:在达到这个大小之前,它仍然可能无法分配存储空间。

    /*======================================
     函数操作:max_size()
     函数形参:无
     函数返回:向量空间能存的最大元素数
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myints;
        for(int i = 1; i <= 10; i++) myints.push_back(i);
        cout << "size: " << myints.size() << endl;
        cout << "capacity: " << myints.capacity() << endl;
        cout << "max_size: " << myints.max_size() << endl;  //因用户电脑情况而定,结果可能不同
        return 0;
    }
    /*=======================================
     函数输出:size: 10
             capacity: 16
             max_size: 4611686018427387903
     =======================================*/

    size:

    返回大小

    size_type size() const;//成员类型size_type是无符号整数类型。

    返回向量中的元素数。这是矢量中保存的实际对象的数量,不一定等于其存储容量。

    /*======================================
     函数操作:size()
     函数形参:无
     函数返回:向量中的元素数
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myints;
        cout << "0.size: " << myints.size() << endl;
        for(int i = 1; i <= 10; i++) myints.push_back(i);
        cout << "1.size: " << myints.size() << endl;
        myints.insert(myints.end(), 10, 100);             //在结尾处插入10个 100
        cout << "3.size: " << myints.size() << endl;
        myints.pop_back();
        cout << "4.size: " << myints.size() << endl;
        return 0;
    }
    /*=======================================
     函数输出:0.size: 0
             1.size: 10
             3.size: 20
             4.size: 19
     =======================================*/

    rsize:

    改变大小-对应于 size()

    void resize (size_type n, value_type val = value_type());

    调整容器大小以使其包含n个元素。如果n小于当前容器大小,则内容将减少为前n个元素,删除超出(并销毁它们)的元素。如果n大于当前容器大小,则通过在末尾插入尽可能多的元素来扩展内容以达到n的大小。如果指定了val,则新元素将初始化为val的副本,否则,它们将进行值初始化。如果n也大于当前容器容量,自动重新分配分配的存储空间。请注意,此函数通过插入或删除容器中的元素来更改容器的实际内容。

    /*======================================
     函数操作:size()
     函数形参:(1)指定大小 n(无符号整型)
             (2)当 n 大于当前容器,将指定内容复制到
                 添加元素的对象。
     函数返回:无
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myints;
        for(int i = 1; i <= 10; i++) myints.push_back(i);
        cout << "size: " << myints.size() << endl;
        myints.resize(5);         //删除并销毁位数 5 之后的数据
        cout << "size: " << myints.size() << endl;
        myints.resize(8, 21);     //在原向量尾以元素 21 扩展到 8 位大小。
        cout << "size: " << myints.size() << endl;
        myints.resize(12);        //在原向量尾以元素 0 扩展到指定为数 12 。
        for(int i = 0; i < myints.size(); i++)
            cout << myints[i] << " ";
        cout<<endl;
        return 0;
    }
    /*=======================================
     函数输出:size: 10
             size: 5
             size: 8
             1 2 3 4 5 21 21 21 0 0 0 0
     =======================================*/

    capacity:

    返回分配的存储容量大小

    size_type capacity() const;

    返回当前分配给向量的存储空间的大小,用元素表示。这个容量不一定等于向量的大小。它可以是相等的或更大的,有额外的空间允许容纳增长,而不需要在每次插入时重新分配。注意,这个容量并不假设向量的大小受到限制。当这个容量耗尽并且需要更多容量时,容器会自动扩展它(重新分配它的存储空间)。向量大小的理论极限由成员max_size给出。向量的容量可以通过调用成员vector::reserve显式地更改。

    /*======================================
     函数操作:size()
     函数形参:(1)指定大小 n(无符号整型)
             (2)当 n 大于当前容器,将指定内容复制到
                 添加元素的对象。
     函数返回:无符号整型
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myints;
        myints.resize(1);
        cout << "size: " << myints.size() << endl;
        cout << "capacity: " << myints.capacity() << endl;
        
        myints.resize(4);
        cout << "size: " << myints.size() << endl;
        cout << "capacity: " << myints.capacity() << endl;
        
        myints.resize(6);
        cout << "size: " << myints.size() << endl;
        cout << "capacity: " << myints.capacity() << endl;
        
        myints.resize(10);
        cout << "size: " << myints.size() << endl;
        cout << "capacity: " << myints.capacity() << endl;
        
        for(int i = 0; i < myints.size(); i++)
            myints[i] = i;
        
        for(int i = 0; i < myints.capacity(); i++)
            cout << myints[i] << " ";
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:size: 1
             capacity: 1
             size: 4
             capacity: 4
             size: 6
             capacity: 8
             size: 10
             capacity: 16
             0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 
     =======================================*/

    reserve:

    请求更改容量-对应于 capacity()

    void reserve (size_type n);

    请求向量容量至少足以包含n个元素。如果n大于当前向量容量,则该函数使容器重新分配其存储,将其容量增加到n(或更大)。在所有其他情况下,函数调用不会导致重新分配,并且矢量容量不会受到影响。此函数对向量大小没有影响,不能改变其元素。

    /*======================================
     函数操作:reserve()
     函数形参:无
     函数返回:无
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myvector;
        vector<int>::size_type sz;
        sz = myvector.capacity();
        
        std::cout << "making foo grow: " << endl;
        for(int i = 0; i < 100; i++)
        {
            myvector.push_back(i);
            if(sz != myvector.capacity())
            {
                sz = myvector.capacity();
                cout << "capacity changed: " << sz << endl;
            }
        }
        
        std::vector<int> bar;
        sz = bar.capacity();
        bar.reserve(100);      //相当于 C 语言中的 malloc,C++ 中的 new,自己开辟一块固定大小的内存空间
        std::cout << "making bar grow:\n";
        for (int i=0; i<100; ++i) {
            bar.push_back(i);
            if (sz!=bar.capacity()) {
                sz = bar.capacity();
                std::cout << "capacity changed: " << sz << '\n';
            }
        }
        return 0;
    }
    /*=======================================
     函数输出: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
             making bar grow:
             capacity changed: 100
     =======================================*/
    

    empty:

    测试向量是否为空

    bool empty() const;

    返回向量是否为空(即其大小是否为0)。此功能不会以任何方式修改容器。要清除向量的内容,请参阅vector :: clear。

    /*======================================
     函数操作:empty()
     函数形参:无
     函数返回:bool 0-非空;1-空
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myints;
        int sum = 0;
        for(int i = 1; i <= 10; i++)
            myints.push_back(i);
        while(!myints.empty())
        {
            sum += myints.back();
            myints.pop_back();
        }
        cout << "total: " << sum << endl;
        return 0;
    }
    /*=======================================
     函数输出:total: 55
     =======================================*/

    Element access(元素访问):

    operator[]:

    返回对向量容器中位置为n的元素的引用。

    reference operator[] (size_type n);//成员类型reference和const_reference是容器元素的引用类型

    类似的成员函数vector::at与这个操作符函数具有相同的行为,但vector::at是有界检查的,如果请求的位置超出范围,则通过抛出out_of_range异常发出信号。可移植程序不应该使用超出范围的参数n调用此函数,因为这会导致未定义的行为。

    注:程序历程见 capacity

    at:

    访问元素

    reference at (size_type n);

    返回对向量中位置n处元素的引用。 该函数自动检查n是否在向量中的有效元素的范围内,如果不是,则抛出out_of_range异常(即,如果n大于或等于其大小)。这与成员运算符[]形成对比,后者不检查边界。

    /*======================================
     函数操作:at()
     函数形参:元素在容器中的位置
     函数返回:该位置元素值
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myvector(10);     //初始化为 10 个 0
        for(int i = 0; i < myvector.size(); i++)
            myvector.at(i) = i;
        
        cout << "myvector contains:";
        for(int i = 0; i < myvector.size(); i++)
            cout << " " << myvector.at(i);
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contains: 0 1 2 3 4 5 6 7 8 9
     =======================================*/

    front:

    访问第一个元素

    reference front();

    返回对向量中第一个元素的引用。与成员vector :: begin不同,它返回一个迭代器到同一个元素,这个函数返回一个直接引用。在空容器上调用此函数会导致未定义的行为。

    /*======================================
     函数操作:front()
     函数形参:无
     函数返回:向量容器中第一个元素的引用
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myvector;
        myvector.push_back(78);
        myvector.push_back(16);
        myvector.front() -= myvector.back();
        cout << "myvector.front() = " << myvector.front() << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector.front() = 62
     =======================================*/

    back:

    访问最后一个元素

    reference back();

    返回对向量中最后一个元素的引用。与成员vector :: end不同,它返回一个直接通过此元素的迭代器,此函数返回一个直接引用。在空容器上调用此函数会导致未定义的行为。


    Modifiers(编辑):

    assign:

    分配向量内容

    range (1)
    template <class InputIterator>
      void assign (InputIterator first, InputIterator last);
    
    fill (2)
    void assign (size_type n, const value_type& val);

    将新内容分配给向量,替换其当前内容(相当于清空),并相应地修改其大小。

    /*======================================
     函数操作:assign()
     函数形参:和创建vector 相同的三种输入形式
     函数返回:无-void
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> first;
        vector<int> secend;
        vector<int> third;
        
        first.assign(7, 100);
        
        vector<int>::iterator it;
        it = first.begin() + 1;
        
        secend.assign(it, first.end() - 1);
        
        int myints[] = {1996, 4, 5};
        third.assign(myints, myints + 3);
        
        cout << "Size of fist: " << first.size() << endl;
        cout << "Size of secend: " << secend.size() << endl;
        cout << "Size of third: " << third.size() << endl;
        return 0;
    }
    /*=======================================
     函数输出:Size of fist: 7
             Size of secend: 5
             Size of third: 3
     =======================================*/

    push_back:

    末尾添加元素

    void push_back (const value_type& val);//成员类型value_type是容器中元素的类型,在向量中定义为其第一个模板参数(T)的别名。

    在向量的末尾添加一个新元素,在其当前的最后一个元素之后。val的内容被复制(或移动)到新元素。这有效地将容器大小增加一,如果 - 并且仅当新的矢量大小超过当前矢量容量时,这导致分配的存储空间的自动重新分配。

    注:见之前程序

    pop_back:

    删除最后一个元素

    void pop_back();

    移除向量中的最后一个元素,有效地将容器大小减少一个。这会破坏已删除的元素。

    注:见 empty();

    insert:

    通过在指定位置的元素之前插入新元素来扩展向量,从而通过插入的元素数量有效地增加容器大小。

    single element (1)
    iterator insert (iterator position, const value_type& val);
    
    fill (2)
        void insert (iterator position, size_type n, const value_type& val);
    
    range (3)
    template <class InputIterator>
        void insert (iterator position, InputIterator first, InputIterator last);

    当且仅当新向量大小超过当前向量容量时,将自动重新分配分配的存储空间。因为向量使用数组作为它们的底层存储,所以将元素插入到向量末端以外的位置会导致容器将位置之后的所有元素重新定位到它们的新位置。与其他类型的序列容器(如list或forward_list)对相同操作执行的操作相比,这通常是一个低效的操作。这些参数决定了插入了多少元素,并将它们初始化为哪些值。

    返回第一个新插入元素的迭代器。

    /*======================================
     函数操作:insert()
     函数形参:(1)插入位置,插入值
             (2)插入位置,插入数量,插入值
             (3)插入位置,另一vector插入起点的 iterator,插入终点iterator
             (4)插入位置,数组插入起点指针,数组插入终点指针
     函数返回:插入元素的第一个元素的 iterator
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> first(3, 100);
        
        vector<int>::iterator it;
        it = first.begin();
        it = first.insert(it, 200);
        
        first.insert(it, 2, 300);
        
        it = first.begin();
        
        vector<int> secend(2, 400);
        first.insert(it + 2, secend.begin(), secend.end());
        
        int myarray[] = {501, 502, 503};
        first.insert(first.begin(), myarray, myarray + 3);
        
        cout << "myvector contains: ";
        for(it = first.begin(); it < first.end(); it++)
            cout << *it << " ";
        cout << endl;
        
        return 0;
    }
    /*=======================================
     函数输出:myvector contains: 501 502 503 300 300 400 400 200 100 100 100
     =======================================*/
    

    erase:

    从向量中移除单个元素(位置)或一系列元素([first,last))。

    iterator erase (iterator position);
    iterator erase (iterator first, iterator last);

    这有效地减少了容器的大小,删除了被删除的元素数量。

    /*======================================
     函数操作:erase()
     函数形参:(1)删除位置
             (2)删除起点iterator,删除终点iterator
     函数返回:iterator,指向调用删除的最后一个额元素后面元素的新位置
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myvector;
        
        // set some values(from 1 to 10)
        for(int i = 1; i <= 10; i++)
            myvector.push_back(i);
        
        //erase the 6th element
        myvector.erase(myvector.begin() + 5);
        
        //erase the first 3 elements
        myvector.erase(myvector.begin(), myvector.begin() + 3);
        
        cout << "myvector contains: ";
        for(unsigned i = 0; i < myvector.size(); i++)
            cout << myvector[i] << " ";
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contains: 4 5 7 8 9 10
     =======================================*/
    

    swap:

    交换内容

    void swap (vector& x);

    通过x的内容交换容器的内容,x是另一个相同类型的矢量对象。尺寸可能不同。在调用此成员函数之后,此容器中的元素是在调用之前在x中的元素,而x的元素是在此中的元素。所有迭代器,引用和指针对交换的对象仍然有效。请注意,存在一个非成员函数,其名称相同,交换,重载该算法,其优化行为与此成员函数类似。

    /*======================================
     函数操作:swap()
     函数形参:要交换的 vector 对象
     函数返回:无 - void
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> foo(3, 100);
        vector<int> bar(5, 200);
        
        foo.swap(bar);
        
        cout << "foo contains: ";
        for(vector<int>::iterator it = foo.begin(); it < foo.end(); it++)
            cout << *it << " ";
        cout << endl;
        
        cout << "bar contains: ";
        for(unsigned i = 0; i < bar.size(); i++)
            cout << bar.at(i) << " ";
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:foo contains: 200 200 200 200 200
             bar contains: 100 100 100
     =======================================*/
    

    clear:

    从向量中删除所有元素(被销毁),使容器的大小为0。

    void clear();

    不能保证重新分配,并且由于调用此函数,不能保证向量容量发生变化。强制重新分配的典型替代方法是使用swap:

    /*======================================
     函数操作:swap()
     函数形参:要交换的 vector 对象
     函数返回:无 - void
     ======================================*/
    #include <iostream>
    #include <vector>
    using namespace std;
    
    int main()
    {
        vector<int> myvector;
        myvector.push_back (100);
        myvector.push_back (200);
        myvector.push_back (300);
        
        cout << "myvector contains:";
        for (unsigned i=0; i<myvector.size(); i++)
            cout << myvector[i] << ' ';
        cout << endl;
        
        myvector.clear();
        myvector.push_back (1101);
        myvector.push_back (2202);
        
        cout << "myvector contains:";
        for (unsigned i=0; i<myvector.size(); i++)
            cout << myvector[i] << ' ';
        cout << endl;
        return 0;
    }
    /*=======================================
     函数输出:myvector contains:100 200 300
             myvector contains:1101 2202
     =======================================*/

     

    展开全文
  • vector容器---容量&大小

    2021-01-26 15:57:55
    1.对vector的容量和大小进行操作。 2.函数原型: empty(); //判断容器是否为空,返回值为真则代表容器空 capacity(); //容器的容量 size(); //返回容器中元素的个数 resize(int num); //重新制定容器的长度为num...

    1.对vector的容量和大小进行操作。

    2.函数原型:

    1. empty(); //判断容器是否为空,返回值为真则代表容器空
    2. capacity();  //容器的容量
    3. size();  //返回容器中元素的个数
    4. resize(int num); //重新制定容器的长度为num,若容器变长,则以默认值填充新位置;若容器变短,则末端超出容器长度的元素被删除。
    5. resize(int num,elem); //重新制定容器的长度为num,若容器变长,则以elem填充新位置;若容器变短,则末端超出容器长度的元素被删除。
      #include<iostream>
      #include<vector>
      using namespace std;
      
      void printvector(vector<int> &v)
      {
      	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
      		cout<<*it<<" ";
      	cout<<endl;
      }
      
      
      void test1()
      {
      	//1.直接插入赋值 
      	vector<int> v;
      	for(int i=0;i<10;i++)
      		v.push_back(i);
      	printvector(v);
      	
      	//2.判断容器是否为空 
      	if(v.empty())  //为真则代表容器空 
      		cout<<"v为空"<<endl;
      	else
      	{
      		cout<<"v不为空,v的容量为:"<<v.capacity()<<",v的大小为:"<<v.size()<<endl;
      	} 
      	
      	//3.重新指定容器大小
      	v.resize(13); 
      	printvector(v); //超出大小的部分用默认值0来代替。 
      	
      	v.resize(15,100); 
      	printvector(v); //超出大小的部分用指定值100来代替。 
      	
      	v.resize(5); //原容器变小,多出的部分直接被删掉了 
      	printvector(v);
       } 
       
      int main()
      {
      	test1();
      	return 0;
      }
      
      /*
      打印结果:
      0 1 2 3 4 5 6 7 8 9
      v不为空,v的容量为:16,v的大小为:10
      0 1 2 3 4 5 6 7 8 9 0 0 0
      0 1 2 3 4 5 6 7 8 9 0 0 0 100 100
      0 1 2 3 4
      */

       

    展开全文
  • 在C++中常用的string的API都学习完了,这篇开始学习vector容器。vector有点类似数组,但是一个最懂扩容和支持尾部插入和删除的类似数组的容器。vector数据结构和数组非常相似,也称为单端数组,不同之处在于数组是...
  • [C++]STL-vector容器

    2021-01-06 23:56:44
    vector容器(动态数组,可变数组) 单口容器 vector动态增长的基本原理 当插入新元素时,如果空间不足,那么vector会重新申请更大的一块内存空间,将原来空间拷贝到新空间上,释放旧空间的数据,再把新元素插入新...
  • 序列式容器 vector 简介 vector ( 向量 ) 头文件 vector ( 向量 ) 声明及初始化 vector ( 向量 ) 添加元素 vector ( 向量 ) 查询元素 vector ( 向量 ) 删除元素 vector ( 向量 ) 容量改变 vector ( 向量 ) 涉及到的...
  • C++vector容器vector容量和大小

    千次阅读 2020-09-04 15:15:15
    C++vector容器vector容量和大小 功能描述: 对vector容器的容量和大小操作 函数原型: empty(); //判断容器是否为空 capacity(); //容器的容量 size(); //返回容器中元素的个数 resize(int num); //重新...
  • vector是STL里常见的容器,虽然和数组一样是顺序容器,但是它可以随着元素的插入不断地扩增自己的容量 vector扩增容量的机制 先看代码 代码中的size()返回vector的大小(也就是目前有多少个元素),而capacity()则...
  • vector容器添加元素

    2021-01-05 21:26:34
    基础不牢,在容器vector上撞墙,做做笔记来吸取教训 vector添加元素,我原来的代码 vector<MetricPoint2D> Smooth::smoothPath(const vector<MetricPoint2D> &path) { int length = path.size(); ...
  • C++中vector容器的用法

    2021-01-21 18:57:47
    在c++中,vector是一个十分有用的容器,下面对这个容器做一下总结。 1 基本操作 (1)头文件#include<vector>. (2)创建vector对象,vector<int> vec; (3)尾部插入数字:vec.push_back(a); (4)使用下标访问元素,cout&...
  • C++中vector容器

    千次阅读 2018-07-30 16:53:46
    一.基本概念: 1.容器容器用来存储数据的,数据...vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。 3....
  • C++语言vector容器介绍和示例

    千次阅读 2019-08-06 08:12:09
    之前我们在声明数组的时候,采用的是datatype array[len]的形式,数组在分配之后,不能调整大小... 与string类一样, 向量vector 同属于STL(Standard Template Library, 标准模板库)中的自定义的类, vector是一个封...
  • C++vector容器-赋值操作

    2021-01-30 00:46:29
    vector容器进行赋值 函数原型: 代码如下: #include <iostream> using namespace std; #include <vector> //vector赋值操作 void printVector(vector<int> &v) { for (vector<int &...
  • C++vector容器vector数据存取 功能描述: 对vector中的数据的存取操作 函数原型: at(int idx); //返回索引idx所指的数据 operator[]; //返回索引idx所指的数据 front(); //返回容器中第一个数据元素 back(); //...
  • C++ vector容器的多种遍历方式

    千次阅读 2021-01-19 22:05:59
    vector容器的遍历方式 //方式一:普通for循环 //方式二:for auto循环 //方式三:迭代器 //方式四:for_each() //方式五:transform() //方式六:copy()+输出流迭代器
  • c++ vector容器的嵌套使用

    千次阅读 2020-09-28 15:19:07
    c++ vector容器的嵌套使用 目录 1、定义 2、添加元素 3、访问元素 4、长度 1、定义 vector<vector<int>> M; 2、添加元素 这里是vector的嵌套使用,本质是vector元素里的每个元素也是...
  • C++ vector容器嵌套容器 vector容器 #include <iostream> #include <vector> using namespace std; void test() { vector<vector<int>> v; vector<int> v1; vector<int> v2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,955
精华内容 66,382
关键字:

vector容器