C++ :vector的使用

vector 定义

vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.

用法:

1.文件包含:

首先在程序开头处加上#include以包含所需要的类文件vector
加上using namespace std;

2.变量声明:

2.1 例:声明一个int向量以替代一维的数组:
vector a;(等于声明了一个int数组a[],大小没有指定,可以动态的向里面添加删除)。

2.2 例:用vector代替二维数组.其实只要声明一个一维数组向量即可,而一个数组的名字其实代表的是它的首地址,所以只要声明一个地址的向量即可,即:vector <int > a.同理想用向量代替三维数组也是一样,vector <int*>a;再往上面依此类推.

3.具体的用法以及函数调用:

3.1 如何得到向量中的元素?其用法和数组一样:
例如:

  vector <int *> a
  int b = 5;
  a.push_back(b);//该函数下面有详解
  cout<<a[0];       //输出结果为5

1.push_back 在数组的最后添加一个数据
2.pop_back 去掉数组的最后一个数据
3.at 得到编号位置的数据
4.begin 得到数组头的指针
5.end 得到数组的最后一个单元+1的指针
6．front 得到数组头的引用
7.back 得到数组的最后一个单元的引用
8.max_size 得到vector最大可以是多大
9.capacity 当前vector分配的大小
10.size 当前使用数据的大小
11.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
12.reserve 改变当前vecotr所分配空间的大小
13.erase 删除指针指向的数据项
14.clear 清空当前的vector
15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)
16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)
17.empty 判断vector是否为空
18.swap 与另一个vector交换数据

3.2 详细的函数实现功能：
其中vector c.
c.clear() 移除容器中所有数据。
c.empty() 判断容器是否为空。
c.erase(pos) 删除pos位置的数据
c.erase(beg,end) 删除[beg,end)区间的数据
c.front() 传回第一个数据。
c.insert(pos,elem) 在pos位置插入一个elem拷贝
c.pop_back() 删除最后一个数据。
c.push_back(elem) 在尾部加入一个数据。
c.resize(num) 重新设置该容器的大小
c.size() 回容器中实际数据的个数。
c.begin() 返回指向容器第一个元素的迭代器
c.end() 返回指向容器最后一个元素的迭代器

4.内存管理与效率

  1》使用reserve()函数提前设定容量大小，避免多次容量扩充操作导致效率低下。

    关于STL容器，最令人称赞的特性之一就是是只要不超过它们的最大大小，它们就可以自动增长到足以容纳你放进去的数据。（要知道这个最大值，只要调用名叫max_size的成员函数。）对于vector和string，如果需要更多空间，就以类似realloc的思想来增长大小。vector容器支持随机访问，因此为了提高效率，它内部使用动态数组的方式实现的。在通过 reserve() 来申请特定大小的时候总是按指数边界来增大其内部缓冲区。当进行insert或push_back等增加元素的操作时，如果此时动态数组的内存不够用，就要动态的重新分配当前大小的1.5~2倍的新内存区，再把原数组的内容复制过去。所以，在一般情况下，其访问速度同一般数组，只有在重新分配发生时，其性能才会下降。正如上面的代码告诉你的那样。而进行pop_back操作时，capacity并不会因为vector容器里的元素减少而有所下降，还会维持操作之前的大小。对于vector容器来说，如果有大量的数据需要进行push_back，应当使用reserve()函数提前设定其容量大小，否则会出现许多次容量扩充操作，导致效率低下。

  reserve成员函数允许你最小化必须进行的重新分配的次数，因而可以避免真分配的开销和迭代器/指针/引用失效。但在我解释reserve为什么可以那么做之前，让我简要介绍有时候令人困惑的四个相关成员函数。在标准容器中，只有vector和string提供了所有这些函数。

(1) size()告诉你容器中有多少元素。它没有告诉你容器为它容纳的元素分配了多少内存。
(2) capacity()告诉你容器在它已经分配的内存中可以容纳多少元素。那是容器在那块内存中总共可以容纳多少元素，而不是还可以容纳多少元素。如果你想知道一个vector或string中有多少没有被占用的内存，你必须从capacity()中减去size()。如果size和capacity返回同样的值，容器中就没有剩余空间了，而下一次插入（通过insert或push_back等）会引发上面的重新分配步骤。
(3) resize(Container::size_type n)强制把容器改为容纳n个元素。调用resize之后，size将会返回n。如果n小于当前大小，容器尾部的元素会被销毁。如果n大于当前大小，新默认构造的元素会添加到容器尾部。如果n大于当前容量，在元素加入之前会发生重新分配。
(4) reserve(Container::size_type n)强制容器把它的容量改为至少n，提供的n不小于当前大小。这一般强迫进行一次重新分配，因为容量需要增加。（如果n小于当前容量，vector忽略它，这个调用什么都不做，string可能把它的容量减少为size()和n中大的数，但string的大小没有改变。在我的经验中，使用reserve来从一个string中修整多余容量一般不如使用“交换技巧”，那是条款17的主题。）

 这个简介表示了只要有元素需要插入而且容器的容量不足时就会发生重新分配（包括它们维护的原始内存分配和回收，对象的拷贝和析构和迭代器、指针和引用的失效）。所以，避免重新分配的关键是使用reserve尽快把容器的容量设置为足够大，最好在容器被构造之后立刻进行。

例如，假定你想建立一个容纳1-1000值的vector。没有使用reserve，你可以像这样来做：

vector v;
for (int i = 1; i <= 1000; ++i) v.push_back(i);
在大多数STL实现中，这段代码在循环过程中将会导致2到10次重新分配。（10这个数没什么奇怪的。记住vector在重新分配发生时一般把容量翻倍，而1000约等于210。）

把代码改为使用reserve，我们得到这个：

vector v;
v.reserve(1000);
for (int i = 1; i <= 1000; ++i) v.push_back(i);
这在循环中不会发生重新分配。

在大小和容量之间的关系让我们可以预言什么时候插入将引起vector或string执行重新分配，而且，可以预言什么时候插入会使指向容器中的迭代器、指针和引用失效。例如，给出这段代码，

string s;
…
if (s.size() < s.capacity()) {
s.push_back(‘x’);
}
push_back的调用不会使指向这个string中的迭代器、指针或引用失效，因为string的容量保证大于它的大小。如果不是执行push_back，代码在string的任意位置进行一个insert，我们仍然可以保证在插入期间没有发生重新分配，但是，与伴随string插入时迭代器失效的一般规则一致，所有从插入位置到string结尾的迭代器/指针/引用将失效。

回到本条款的主旨，通常有两情况使用reserve来避免不必要的重新分配。第一个可用的情况是当你确切或者大约知道有多少元素将最后出现在容器中。那样的话，就像上面的vector代码，你只是提前reserve适当数量的空间。第二种情况是保留你可能需要的最大的空间，然后，一旦你添加完全部数据，修整掉任何多余的容量。

   2》使用“交换技巧”来修整vector过剩空间/内存

  有一种方法来把它从曾经最大的容量减少到它现在需要的容量。这样减少容量的方法常常被称为“收缩到合适（shrink to fit）”。该方法只需一条语句：vector<int>(ivec).swap(ivec);

表达式vector(ivec)建立一个临时vector，它是ivec的一份拷贝：vector的拷贝构造函数做了这个工作。但是，vector的拷贝构造函数只分配拷贝的元素需要的内存，所以这个临时vector没有多余的容量。然后我们让临时vector和ivec交换数据，这时我们完成了，ivec只有临时变量的修整过的容量，而这个临时变量则持有了曾经在ivec中的没用到的过剩容量。在这里（这个语句结尾），临时vector被销毁，因此释放了以前ivec使用的内存，收缩到合适。

 3》用swap方法强行释放STL Vector所占内存

template < class T> void ClearVector( vector& v )
{
vectorvtTemp;
vtTemp.swap( v );
}
如
vector v ;
nums.push_back(1);
nums.push_back(3);
nums.push_back(2);
nums.push_back(4);
vector().swap(v);

/* 或者v.swap(vector()); */

/或者{ std::vector tmp = v; v.swap(tmp); }; //加大括号{ }是让tmp退出{ }时自动析构/

5.Vector 内存管理成员函数的行为测试

   C++ STL的vector使用非常广泛，但是对其内存的管理模型一直有多种猜测，下面用实例代码测试来了解其内存管理方式，测试代码如下：

#include
#include
using namespace std;

int main()
{
vector iVec;
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //1个元素， 容器容量为1

iVec.push_back(1);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //2个元素， 容器容量为2

iVec.push_back(2);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //3个元素， 容器容量为4

iVec.push_back(3);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //4个元素， 容器容量为4

iVec.push_back(4);
iVec.push_back(5);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //5个元素， 容器容量为8

iVec.push_back(6);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //6个元素， 容器容量为8

iVec.push_back(7);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //7个元素， 容器容量为8

iVec.push_back(8);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //8个元素， 容器容量为8

iVec.push_back(9);
cout << "容器 大小为: " << iVec.size() << endl;
cout << "容器 容量为: " << iVec.capacity() << endl; //9个元素， 容器容量为16
/* vs2005/8 容量增长不是翻倍的，如
9个元素 容量9
10个元素 容量13 */

/* 测试effective stl中的特殊的交换 swap() */
cout << "当前vector 的大小为: " << iVec.size() << endl;
cout << "当前vector 的容量为: " << iVec.capacity() << endl;
vector(iVec).swap(iVec);

cout << "临时的vector对象 的大小为: " << (vector(iVec)).size() << endl;
cout << "临时的vector对象 的容量为: " << (vector(iVec)).capacity() << endl;
cout << "交换后，当前vector 的大小为: " << iVec.size() << endl;
cout << "交换后，当前vector 的容量为: " << iVec.capacity() << endl;

return 0;
}

6.vector的其他成员函数

    c.assign(beg,end)：将[beg; end)区间中的数据赋值给c。
    c.assign(n,elem)：将n个elem的拷贝赋值给c。 
    c.at(idx)：传回索引idx所指的数据，如果idx越界，抛出out_of_range。 
    c.back()：传回最后一个数据，不检查这个数据是否存在。
    c.front()：传回地一个数据。 
    get_allocator：使用构造函数返回一个拷贝。 
    c.rbegin()：传回一个逆向队列的第一个数据。 
    c.rend()：传回一个逆向队列的最后一个数据的下一个位置。 
    c.~ vector <Elem>()：销毁所有数据，释放内存。    

vector 其他用法

内部排序

通过sort函数实现整个vector变量的内部元素排序
eg：

vector<string> classesname_x_second;
 //正向排序：按照从小到大的顺序进行排序
sort(classesname_x_second.begin(), classesname_x_second.end());

 //逆向排序：按照从大到小的顺序进行排序
sort(classesname_x_second.rbegin(), classesname_x_second.rend());

内部元素交换位置

swap(初始位置，新位置)
eg：
result_up[j]与 result_up[j+1]交换位置

swap(result_up[j], result_up[j+1]);

删除元素

erase()可以删除由一个iterator指出的元素，也可以删除一个指定范围的元素。

还可以采用通用算法remove()来删除vector容器中的元素，
不同的是，采用remove一般情况下不会改变容器的大小，而pop_back()与erase()等成员函数会改变容器的大小。

erase

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

erase：
erase函数可以用于删除vector容器中的一个或者一段元素，在删除一个元素的时候，其参数为指向相应元素的迭代器，而在删除一段元素的时候，参数为指向一段元素的开头的迭代器以及指向结尾元素的下一个元素的迭代器。

在进行单个元素删除后，传入的迭代器指向不变，仍然指向被删除元素的位置，而被删除元素之后的所有元素都向前移动一位，也就是该迭代器实际上是指向了原来被删除元素的下一个元素。其实vector还维持着一个last指针，开始的时候=end，随着删除，last前移，最终vector的size是last-begin，或者我们可以认为end值改变了，但最初传入的end没有变。

用例：

vector<int>::iterator itr = v.begin();
   while (itr!=v.end())
   {
    if (*v==1)
    {
          v.erase(itr);
     }
    itr++;//这里删除后迭代器会更新出错
   }

以上代码是错误的，
因为删除一个元素之后，迭代器已经指向了被删除元素的下一个元素，再进行itr++会出现野指针。
也就是说veci.erase(iter)后，iter的状态是不确定的，再进行++，岂有不崩溃的道理？！

正确代码为

vector<int>::iterator itr = v.begin();
   while (itr!=v.end())
   {
       if (*v==1)
    {
        itr=v.erase(itr);
    }
       else
       itr++;
   }

也就是说如果没有erase操作，再将迭代器指向下一个元素。

删除一段元素后，传入的迭代器指向也是不变的，仍然指向原来传进去时候的位置，修改的是删除段后面的元素的位置。删除段后面的元素都前移了。被删除段用被删除段的下一个元素代替了。

remove：

remove() 算法由定义在 algorithm 头文件中的模板生成，它可以删除匹配特定值的一段元素

iterator remove(iterator first, iterator last，val);
remove函数会将范围内所有等于val的值移动位置

STL中remove（）只是将待删除元素之后的元素移动到vector的前端，而不是删除。若要真正移除，需要搭配使用erase()。

vector中的remove的作用是将等于value的元素放到vector的尾部，但并不减少vector的size。STL和vector这两句表达的意思一样。

执行remove之后返回新的end()迭代器，但是不改变原来数组的end()迭代器的值，将范围内值等于val的元素用后一个元素替代。也就是原先数组中新的end()至原end()范围内的值仍为原来数组的值（等于val的值），但是这部分状态不可靠。begin()到新的end()这部分是不等于val的值。

区别：

也就是说erase和remove的区别在于执行函数之后返回值不同，被执行的vector的大小会不会改变

vector中erase的作用是删除掉某个位置position或一段区域（begin, end)中的元素，减少其size，返回被删除元素下一个元素的位置。

vector中remove的作用是将范围内为val的值都remove到后面，返回新的end()值（非val部分的end）,但传入的原vector的end并没有发生改变，因此size也就没有变化

两者结合应用：
删除vector中值为x的元素

vec.erase(remove(vec.begin(),vec.end(),x),vec.end());

具体可参见leetcode26

重复元素只保留一个，对重复的原地移除。

思路：可以将重复的元素用一个特殊值替代，再统一删除这个特殊值。

class Solution {
public:
int removeDuplicates(vector& nums) {

    if(nums.size()==0)
        return 0;
    int res=1;
    int flag=nums[0];
    for(int i=1;i<nums.size();i++)
    {
        if(nums[i]==flag)
            nums[i]=INT_MAX;
        else
        {
            flag=nums[i];
        }
            
    }
    nums.erase(remove(nums.begin(),nums.end(),INT_MAX),nums.end());
    return nums.size();
}

};

pop_back()

删除容器尾部的元素。例如：

std::vector data(100, 99); // Contains 100 elements initialized to 99
data.pop_back(); // Remove the last element

clear()

删除所有的元素。例如：

std::vector data(100, 99);// Contains 100 elements initialized to 99
data.clear(); // Remove all elements

eg:

#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
using namespace std;
 
typedef struct rect //定义结构体
{
    int id;
    int length;
    int width;
    rect(int i,int l ,int w):id(i),length(l),width(w){};
} Rect;
 
int main()
{
    Rect rect(1,2,3);        
    vector<Rect> vec(2,rect);//定义一个含有2个元素rect的vec容器
    Rect rect2(3,3,4);    
    vec.push_back(rect2);
    Rect rect3(4,5,7);    
    vec.push_back(rect3);
    Rect rect4(6,3,4);    
    vec.push_back(rect4);
 
    /**********************删除前遍历输出****************************/
    for(vector<Rect>::iterator it=vec.begin();it!=vec.end();++it){
        cout<<(*it).id<<','<<(*it).length<<','<<(*it).width<<endl;  
        }  
    /**********************删除****************************/
    for(vector<Rect>::iterator it=vec.begin();it!=vec.end();){
        Rect temp=*it;
        if(temp.id==4){
            it=vec.erase(it); //删除元素，返回值指向已删除元素的下一个位置                
        }
        else
            ++it;     
    }
    cout<<"/***********split*************/"<<endl;
    /**********************删除后遍历输出***************************/
    for(size_t i=0;i!=vec.size();++i){
        cout<<vec[i].id<<" "<<vec[i].length<<" "<<vec[i].width<<endl;
    }
 
    return 0;
 
}

实战

题意是acm的排名系统。

#include <bits/stdc++.h>

using namespace std;

typedef struct node {
    int date,peer;
} ty;

bool rule( ty a, ty b ) // sort的简易自定义函数
{
    if ( a.date!=b.date ) {
        return a.date>b.date;
    }
    return a.peer<b.peer;
}

int main()
{
    vector <node> a;
    int n;
    ty t;
    cin >> n;
    for ( int i=0; i<n; i++ ) {
        cin >> t.date>>t.peer;
        a.push_back(t);  // vector中的插入
    }
    sort(a.begin(),a.end(),rule); // vector的sort排序

    vector<node>::iterator p;  // vector的迭代器
    for ( p=a.begin(); p!=a.end(); p++ ) {
        cout << p->date << " " << p->peer << endl; // 迭代器的使用
    }

    return 0;
}

原文链接：https://blog.csdn.net/weixin_43828245/article/details/90243175

vector<bbox_t> result_vec;
//筛选准确度大于90%的检测结果
vector<bbox_t>::iterator itr = result_vec.begin();
for (itr = result_vec.begin(); itr != result_vec.end(); itr++)
{   
		bbox_t temp = *itr;
		if(temp.prob < 0.9)
		result_vec.erase(itr);      //Delete the second element
}

删除指定id元素

int id_prob;
	for (int k2 = 0; k2 < classesname_xup_second.size(); k2++)
	{
		if (classesname_xup_second[k2 + 1] - classesname_xup_second[k2] < 8)    //同一个字符被判断两次
		{
			if (result_up_prob[k2] < result_up_prob[k2 + 1]) 
				id_prob = k2;
			else
				id_prob = k2+1;
			result_up.erase(result_up.begin() + id_prob);
		}
	}

CString插入元素

v2.insert(v2.begin()+4, L"3");   //在指定位置，例如在第五个元素前插入一个元素
 
v2.insert(v2.end(), L"3");   //在末尾插入一个元素
 
v2.push_back(L"9");   //在末尾插入一个元素
 
v2.insert(v2.begin(), L"3");   //在开头插入一个元素

在用vector的过程中的一些问题,特此列出讨论:

           1)
                vector <int > a;
                int  b = 5;
                a.push_back(b);
                此时若对b另外赋值时不会影响a[0]的值

            2)
                vector <int*> a;
                 int *b;
                 b= new int[4];
                 b[0]=0;
                 b[1]=1;
                 b[2]=2;
                 a.push_back(b);
                 delete b;          //释放b的地址空间
                 for(int i=0 ; i <3 ; i++)
                 {
                       cout<<a[0][i]<<endl;
                 }
                 此时输出的值并不是一开始b数组初始化的值,而是一些无法预计的值.
                分析:根据1) 2)的结果,可以想到,在1)中,  往a向量中压入的是b的值,即a[0]=b,此时a[0]和b是存储在两个不同的地址中的.因此改变b的值不会影响a[0];而在2)中,因为是把一个地址(指针)压入向量a,即a[0]=b,因此释放了b的地址也就释放了a[0]的地址,因此a[0]数组中存放的数值也就不得而知了.