C++ vector

最新推荐文章于 2025-06-28 19:38:48 发布

蘑菇ding

最新推荐文章于 2025-06-28 19:38:48 发布

阅读量750

点赞数

CC 4.0 BY-SA版权

分类专栏： c++

本文链接：https://blog.youkuaiyun.com/Cassiel_Paris/article/details/80221136

c++ 专栏收录该内容

21 篇文章

订阅专栏

本文深入讲解C++标准库中的vector容器，包括基本概念、构造方式、成员函数介绍及使用示例，帮助读者全面掌握vector的使用技巧。

std::vector

template < class T, class Alloc = allocator<T> > class vector; // generic template

vector是同一种类型的对象的集合，是代表可以改变大小的数组的顺序容器。就像数组一样，vector为它们的元素使用连续的存储位置，也就是说它们的元素也可以通过指向其的常规指针上的偏移量进行访问，并且与数组中的效率一样高。但是与数组不同的是，它们的大小可以动态改变，它们的存储由vector自动处理。

作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

特别注意：
使用vector需要注意以下几点：
1、如果你要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低；
2、Vector作为函数的参数或者返回值时，需要注意它的写法：
double Distance(vector<int>&a, vector<int>&b) 其中的“&”绝对不能少！！！
实例：vector<int>test;
//建立一个vector，int为数组元素的数据类型，test为动态数组名
简单的使用方法如下：
vector<int>test;//建立一个vector
test.push_back(1);
test.push_back(2);//把1和2压入vector，这样test[0]就是1,test[1]就是
自己见到的实例：
vector<vector<Point2f> > points; //定义一个二维数组
points[0].size(); //指第一行的列数
1 、基本操作
(1)头文件#include<vector>.
(2)创建vector对象，vector<int> vec;
(3)尾部插入数字：vec.push_back(a);
(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。
(5)使用迭代器访问元素.
vector<int>::iterator it;
for(it=vec.begin();it!=vec.end();it++)
cout<<*it<<endl;
(6)插入元素： vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;
(7)删除元素： vec.erase(vec.begin()+2);删除第3个元素
vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始
(8)向量大小:vec.size();
(9)清空:vec.clear();
特别提示：这里有begin()与end()函数、front()与back()的差别
2、重要说明

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

vec.begin()//指向迭代器中第一个元素。   
vec.end()//指向迭代器中末端元素的下一个，指向一个不存在元素。          
vec.push_back(elem)     //在尾部加入一个数据。  
vec.pop_back()          //删除最后一个数据。  
vec.capacity()  //vector可用空间的大小。  
vec.size()//返回容器中数据个数。  
vec.empty() //判断容器是否为空。  
vec.front()     //传回第一个数据。  
vec.back()  //传回最后一个数据，不检查这个数据是否存在。  
vec.at(index)   //传回索引idx所指的数据，如果idx越界，抛出out_of_range。  
vec.clear() //移除容器中所有数据。  
vec.erase(iterator) //删除pos位置的数据，传回下一个数据的位置。  
vec.erase(begin,end)    //删除[beg,end)区间的数据，传回下一个数据的位置。注意：begin和end为iterator  
vec.insert(position,elem)   //在pos位置插入一个elem拷贝，传回新数据位置。  
vec.insert(position,n,elem) //在pos位置插入n个elem数据，无返回值。  
vec.insert(position,begin,end)  //在pos位置插入在[beg,end)区间的数据，无返回值。

#include <iostream>
#include <vector>

/*template <class InputIterator>
  void assign (InputIterator first, InputIterator last);
  void assign (size_type n, const value_type& val);
  void assign (initializer_list<value_type> il);
*/

using namespace std;
//using namespace std::vector;
// vector assign

int main ()
{
  vector<int> first;
  vector<int> second;
  vector<int> third;

  first.assign (7,100);             // 7 ints with a value of 100
  //assign赋值方法，释放了原来的数据空间，并分配了新的数据空间， Assign(x, y)  x表示元素个数， y表示所有元素要初始化的数值

  vector<int>::iterator it;
  it=first.begin()+1;

  second.assign (it,first.end()-1); // the 5 central values of first
  //first.end()-1 所指向的元素不参与赋值

  int myints[] = {1776,7,4};
  third.assign (myints,myints+3);   // assigning from array.
  //myints+3 所指向的元素不参与赋值

  vector<int> forth = {1,2};
  forth.assign({3,4,5,6,7,8});//C++11
  //同样释放了原来的内存空间，分配新空间并把大括号中的数值复制到分配的内存空间
  cout << "Size of first: " << int (first.size()) << '\n';
  cout << "Size of second: " << int (second.size()) << '\n';
  cout << "Size of third: " << int (third.size()) << '\n';
  cout << "Size of third: " << int (forth.size()) << '\n';
  return 0;
}

#include <iostream>
#include <vector>

using namespace std;

// vector::at


int main ()
{
  vector<int> myvector (10);   // 10 zero-initialized ints

  // assign some values:
  for (unsigned i=0; i<myvector.size(); i++)
    myvector.at(i)=i;

  cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); i++)
    cout << ' ' << myvector.at(i);
  cout << '\n';

  return 0;
}

#include <iostream>
#include <vector>

using namespace std;


// vector::back //传回最后一个数据，不检查这个数据是否存在。

int main ()
{
  vector<int> myvector;

  myvector.push_back(10);//在尾部加入一个数据。

  while (myvector.back() != 0)
  {
    myvector.push_back ( myvector.back() -1 );
  }

  cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size() ; i++)
    cout << ' ' << myvector[i];
  cout << '\n';

  return 0;
}

#include <iostream>
#include <vector>

using namespace std;
// vector::begin/end
//begin() 指向 向量中的第一个元素的 迭代器
//end() 结尾标志，不指向任何元素
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 << '\n';

  return 0;
}

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

// comparing size, capacity and max_size
//size()   size是当前vector容器真实占用的大小，也就是容器当前拥有多少个元素。
//capacity() 可以理解为系统为向量预分配的空间大小，超过此空间就需要重新为新元素分配内存
//max_size()  一般为一个很大的数
//在STL中，拥有capacity属性的容器只有vector和string。
int main ()
{
  std::vector<int> myvector;

  // set some content in the vector:
  for (int i=0; i<100; i++)
    myvector.push_back(i);

  std::cout << "size: " << (int) myvector.size() << '\n';
  std::cout << "capacity: " << (int) myvector.capacity() << '\n';
  std::cout << "max_size: " << (int) myvector.max_size() << '\n';
  return 0;
}

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

// vector::cbegin/cend
//cbegin() 返回 一个指向第一个元素的const_iterator
//cend()   返回 结尾标志 const_iterator
//不允许通过迭代器修改向量元素值
int main ()
{
  std::vector<int> myvector = {10,20,30,40,50};

  std::cout << "myvector contains:";
//auto可以在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型，类似的关键字还有decltype

  for (auto it = myvector.cbegin(); it != myvector.cend(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

#include <iostream>
#include <vector>
using namespace std;
// clearing vectors

int main ()
{
  std::vector<int> myvector;
  myvector.push_back (100);
  myvector.push_back (200);
  myvector.push_back (300);

  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); i++)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  myvector.clear();
  myvector.push_back (1101);
  myvector.push_back (2202);

  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); i++)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

#include <iostream>
#include <vector>
using namespace std;
// vector::crbegin/crend
//crbegin()  返回一个指向最后一个元素的const iterator
//crend() 标志开始状态 返回const iterator
int main ()
{
  std::vector<int> myvector = {1,2,3,4,5};

  std::cout << "myvector backwards:";
  for (auto rit = myvector.crbegin(); rit != myvector.crend(); ++rit)
    std::cout << ' ' << *rit;
  std::cout << '\n';

  return 0;
}

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

// vector::data
//返回指向vector中第一个数据的指针或空vector之后的位置
int main ()
{
  std::vector<int> myvector (5);

  int* p = myvector.data();

  *p = 10;
  ++p;
  *p = 20;
  p[2] = 100;

  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); ++i)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

#include <iostream>
#include <vector>
using namespace std;
// vector::emplace  在指定位置插入元素
//emplace() 返回指向新安置的元素的迭代器。
// position value
int main ()
{
  std::vector<int> myvector = {10,20,30};

  auto it = myvector.emplace ( myvector.begin()+1, 100);
  myvector.emplace ( it, 200 );
  myvector.emplace ( myvector.end(), 300 );

  std::cout << "myvector contains:";
  for (auto& x: myvector)
    std::cout << ' ' << x;
  std::cout << '\n';

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

// vector::emplace_back 
//Inserts a new element at the end of the vector, right after its current last element.

int main ()
{
  std::vector<int> myvector = {10,20,30};

  myvector.emplace_back (100);
  myvector.emplace_back (200);

  std::cout << "myvector contains:";
  for (auto& x: myvector)
    std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

#include <iostream>
#include <vector>
using namespace std;
// vector::empty
//Returns whether the vector is empty (i.e. whether its size is 0).
//true if the container size is 0, false otherwise.
int main ()
{
  std::vector<int> myvector;
  int sum (0);

  for (int i=1;i<=10;i++)
    myvector.push_back(i);

  while (!myvector.empty())
  {
     sum += myvector.back();
     myvector.pop_back();//Removes the last element in the vector

  }
  std::cout << "total: " << sum << '\n';

  return 0;
}

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

// erasing from vector
//C89(iterator) C11(const iterator)
//Removes from the vector either a single element (position)
//or a range of elements ([first,last)).
// Return An iterator pointing to the new location of the element that followed the last element erased by the function call.
int main ()
{
  std::vector<int> myvector;
  vector<int>::iterator it;
  // set some values (from 1 to 10)
  for (int i=1; i<=10; i++)
    myvector.push_back(i);

  // erase the 6th element
  it=myvector.erase (myvector.begin()+5);
   cout<<*it<<endl;
  // erase the first 3 elements:
 it= myvector.erase (myvector.begin(),myvector.begin()+3);
  cout<<*it<<endl;
  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); ++i)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

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

// vector::front
//Returns a reference to the first element in the vector.
int main ()
{
  std::vector<int> myvector;

  myvector.push_back(78);
  myvector.push_back(16);

  // now front equals 78, and back 16

  myvector.front() -= myvector.back();

  std::cout << "myvector.front() is now " << myvector.front() << '\n';

  return 0;
}

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

// vector::get_allocator
//Returns a copy of the allocator object associated with the vector.
int main ()
{
  std::vector<int> myvector;
  int * p;
  unsigned int i;

  // allocate an array with space for 5 elements using vector's allocator:
  p = myvector.get_allocator().allocate(5);

  // construct values in-place on the array:
  for (i=0; i<5; i++) myvector.get_allocator().construct(&p[i],i);

  std::cout << "The allocated array contains:";
  for (i=0; i<5; i++) std::cout << ' ' << p[i];
  std::cout << '\n';

  // destroy and deallocate:
  for (i=0; i<5; i++) myvector.get_allocator().destroy(&p[i]);
  myvector.get_allocator().deallocate(p,5);

  return 0;
}

insert

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

// inserting into a vector

int main ()
{
  std::vector<int> myvector (3,100);
  std::vector<int>::iterator it;

  it = myvector.begin();
  it = myvector.insert (it, 200 );//插入位置 插入值

  myvector.insert (it,2,300);//插入位置 数量 插入值

  // "it" no longer valid, get a new one:
  it = myvector.begin();

  std::vector<int> anothervector (2,400);
  myvector.insert (it+2,anothervector.begin(),anothervector.end());
  //插入位置   待插入元素序列向量起始点 待插入元素序列向量终点

  int myarray [] = { 501,502,503 };
  myvector.insert (myvector.begin(), myarray+1, myarray+3);//
  //插入位置   待插入元素序列数组起点 待插入元素序列数组终点
  std::cout << "myvector contains:";
  for (it=myvector.begin(); it<myvector.end(); it++)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

= []

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

// vector assignment =
// vector::operator[]

int main ()
{
  std::vector<int> foo (3,0);
  std::vector<int> bar (5,0);

  bar = foo;
  foo = std::vector<int>();

  std::cout << "Size of foo: " << int(foo.size()) << '\n';
  std::cout << "Size of bar: " << int(bar.size()) << '\n';



  std::vector<int> myvector (10);   // 10 zero-initialized elements

  std::vector<int>::size_type sz = myvector.size();

  // assign some values:
  for (unsigned i=0; i<sz; i++) myvector[i]=i;

  // reverse vector using operator[]:
  for (unsigned i=0; i<sz/2; i++)
  {
    int temp;
    temp = myvector[sz-1-i];
    myvector[sz-1-i]=myvector[i];
    myvector[i]=temp;
  }

  std::cout << "myvector contains:";
  for (unsigned i=0; i<sz; i++)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

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


// vector::rbegin/rend
//rbegin()returns a reverse iterator pointing to the last element in the vector
//rend()  Returns a reverse iterator pointing to the theoretical element preceding the first element in the vector

int main ()
{
  std::vector<int> myvector (5);  // 5 default-constructed ints

  int i=0;

  std::vector<int>::reverse_iterator rit = myvector.rbegin();
  for (; rit!= myvector.rend(); ++rit)
    *rit = ++i;

  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

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


// vector::reserve

int main ()
{
  std::vector<int>::size_type sz;

  std::vector<int> foo;
  sz = foo.capacity();
  std::cout << "making foo grow:\n";
  for (int i=0; i<100; ++i) {
    foo.push_back(i);
    if (sz!=foo.capacity()) {
      sz = foo.capacity();
      std::cout << "capacity changed: " << sz << '\n';
    }
  }

  std::vector<int> bar;
  sz = bar.capacity();
  bar.reserve(100);   // this is the only difference with foo above
  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;
}

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

// resizing vector
//不够的默认置0
int main ()
{
  std::vector<int> myvector;

  // set some initial content:
  for (int i=1;i<10;i++)
    myvector.push_back(i);

  myvector.resize(5);
  myvector.resize(8,100);// 新加的空间 100填充
  myvector.resize(12);

  std::cout << "myvector contains:";
  for (int i=0;i<myvector.size();i++)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';

  return 0;
}

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

// vector::shrink_to_fit
// 请求容器降低其容量和size匹配。
int main ()
{
  std::vector<int> myvector (100);
  std::cout << "1. capacity of myvector: " << myvector.capacity() << '\n';

  myvector.resize(10);
  std::cout << "2. capacity of myvector: " << myvector.capacity() << '\n';

  myvector.shrink_to_fit();
  std::cout << "3. capacity of myvector: " << myvector.capacity() << '\n';

  return 0;
}

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

// vector::emplace_back 
//Inserts a new element at the end of the vector, right after its current last element.

int main ()
{
  std::vector<int> myvector = {10,20,30};

  myvector.emplace_back (100);
  myvector.emplace_back (200);

  std::cout << "myvector contains:";
  for (auto& x: myvector)
    std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

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


// swap vectors


int main ()
{
  std::vector<int> foo (3,100);   // three ints with a value of 100
  std::vector<int> bar (5,200);   // five ints with a value of 200


  foo.swap(bar);


  std::cout << "foo contains:";
  for (unsigned i=0; i<foo.size(); i++)
    std::cout << ' ' << foo[i];
  std::cout << '\n';


  std::cout << "bar contains:";
  for (unsigned i=0; i<bar.size(); i++)
    std::cout << ' ' << bar[i];
  std::cout << '\n';


  return 0;
}

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

// vector::emplace_back 
//Inserts a new element at the end of the vector, right after its current last element.

int main ()
{
  std::vector<int> myvector = {10,20,30};

  myvector.emplace_back (100);
  myvector.emplace_back (200);

  std::cout << "myvector contains:";
  for (auto& x: myvector)
    std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}