C++ Vector的使用

一. 什么是vector？

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

使用它时需要包含头文件：

#include<vector>;

简单定义

vector<类型>标识符
vector<类型>标识符(最大容量)
vector<类型>标识符(最大容量,初始所有值)
vector< vector< int> > v(m_size, vector<int>(n_size)); 声明一个二维向量，第一维大小为m_size，第二维是n_size。

二. 基本函数实现

1. 构造函数

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中

例如：

(1) vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
（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）int b[7]={1,2,3,4,5,9,8};
        vector<int> a(b,b+7); //从数组中获得初值

2. 增加函数

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)间的数据

例如：

（1）a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5
（2）a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
（3）a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5，如a为1，2，3，4，插入元素后为1，5，5，5，2，3，4
（4）a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如a为1，2，3，4，  b为11，10，9，8，7，6，5，  插入元素后为1，8，7，6，2，3，4

2020.7.21.

emplace_back也可以向vector增加元素。与push_back的区别：

使用push_back()向容器中加入一个右值元素(临时对象)时，首先会调用构造函数构造这个临时对象，然后需要调用拷贝构造函数将这个临时对象放入容器中。原来的临时变量释放。这样造成的问题就是临时变量申请资源的浪费。

emplace_back在容器尾部添加一个元素，这个元素原地构造，不需要触发拷贝构造和转移构造。而且调用形式更加简洁，直接根据参数初始化临时对象的成员。

3. 删除函数

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

例如：

（1）a.erase(a.begin()); //删除a的第一个元素
（2）a.erase(a.begin(), a.begin()+3); // 删除a中第一个元素到第三个元素，如a为1，2，3，4，删除后为4
（3）a.pop_back(); // a为1，2，3，4，删除后为1，2，3
（4）a.clear(); // 清空a

注意pop_back可以一次性删除若干个最后的元素，如：

for(int i=0;i<5;i++)//去掉数组最后一个数据 
    {
        obj.pop_back();
    }
// obj为0，1,2,3,4,5,6,7,8,9,执行上述代码后为0，1，2，3，4

4. 遍历函数

begin():返回向量头指针，指向第一个元素
end():返回向量尾指针，指向向量最后一个元素的下一个位置
rbegin():反向迭代器，指向最后一个元素
rend():反向迭代器，指向第一个元素之前的位置

5. 判断函数

bool empty():判断向量是否为空，若为空，则向量中无元素

6. 大小函数

int size():返回向量中元素的个数
int capacity():返回当前向量所能容纳的最大元素值
int max_size():返回最大可允许的vector元素数量值

7. 其他函数

void swap(vector&):交换两个同类型向量的数据
void assign(int n,const T& x):向量中的元素个数为n，且n个数都为x
void assign(const_iterator first,const_iterator last):另一个向量中[first,last)中的元素设置成当前向量元素
find(vector.begin(), vector.end(), int element): 前两个元素指定查找的范围，第三个元素是待查找的元素。vector与find一起使用,调用find时，需要指明头文件#include<algorithm>。一般这么使用：

find(vector.begin(), vector.end(), element) != vector.end() //表示在vector中查找到了元素element，否则就是没有查找到。

sort(vector.begin(), vectr.end(),sorted_method): 按排序方法对vector排序，默认是升序排序。如果要实现降序排序，可以这样实现

第一种：sort(vector.begin(), vector.end(), greater<int>()) // 这里greater表示更大，int表示元素类型,这样就可以实现降序排序，需要添加头文件#include<functional>
第二种：指明cmp函数

　　　　static bool cmp(int x,int y){ return x > y; } // 这里需要在前面加上static，sort函数的第三个参数是一个函数指针，加上static就是静态成员函数指针，和普通函数指针没有区别

　　　　sort(vector.begin(), vector.end(), cmp)

例如：

a.assign(4, 10); // 如a为1，2，3，4，5，执行之后为10，10，10，10
a.assign(b.begin(), b.begin()+3); 如a为1，2，3，4，5， b为10，11，12，13，执行之后为10，11，12

8. 代码

#include <vector>
#include <iostream>
using namespace std;
 
int main()
{
    //顺序访问，输入用push_back
    vector<int>obj;
    for(int i=0;i<10;i++)
    {
        obj.push_back(i);   
    } 
 　　// 输出方式和数组相同
    cout<<"直接利用数组："; 
    for(int i=0;i<10;i++)//方法一 
    {
        cout<<obj[i]<<" ";
    }
 
    cout<<endl; 
    cout<<"利用迭代器：" ;
    //方法二，使用迭代器将容器中数据输出 
    vector<int>::iterator it;//声明一个迭代器，来访问vector容器，作用：遍历或者指向vector容器的元素 
    for(it=obj.begin();it!=obj.end();it++)
    {
        cout<<*it<<" ";
    }
    return 0;
}

二维数组两种定义方式

方式一

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
 
int main()
{
    int N=5, M=6; 
    vector<vector<int> > obj(N); //定义二维动态数组大小5行 
    for(int i =0; i< obj.size(); i++)//动态二维数组为5行6列，值全为0 
    { 
        obj[i].resize(M); 
    } 
 
    for(int i=0; i< obj.size(); i++)//输出二维动态数组 
    {
        for(int j=0;j<obj[i].size();j++)
        {
            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}

方式二

#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
 
 
int main()
{
    int N=5, M=6; 
    vector<vector<int> > obj(N, vector<int>(M)); //定义二维动态数组5行6列 
 
    for(int i=0; i< obj.size(); i++)//输出二维动态数组 
    {
        for(int j=0;j<obj[i].size();j++)
        {
            cout<<obj[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}

二维数组push_back

vector<vector<int>> result;
result.push_back({i, j, k});

参考

https://www.runoob.com/w3cnote/cpp-vector-container-analysis.html

https://www.cnblogs.com/Nonono-nw/p/3462183.html

posted @ 2020-04-20 11:25 Crazy_Coding 阅读(169) 评论(0) 收藏举报

刷新页面返回顶部

Crazy_Coding