C++STL容器之Vector详解

类型名称	描述
allocator_type	类型，它代表向量对象的分配器类。
const_iterator	类型，它提供可读取矢量中 const 元素的随机访问迭代器。
const_pointer	类型，它提供指向矢量中 const 元素的指针。
const_reference	类型，此类型提供对用于读取和执行 const 操作的矢量中存储的 const 元素的引用。
const_reverse_iterator	类型，它提供可读取矢量中任何 const 元素的随机访问迭代器。
difference_type	类型，它提供矢量中两个元素的址间的差异。
Iterator	类型，它提供可读取或修改向量中任何元素的随机访问迭代器。
pointer	类型，提供指向向量中元素的指针。
reference	类型，它提供对向量中存储的元素的引用。
reverse_iterator	类型，它提供可读取或修改反向矢量中的任意元素的随机访问迭代器。
size_type	类型，它计算矢量中的元素数目。
value_type	类型，它代表向量中存储的数据类型。

成员函数

成员函数	描述
assign	清除并将指定的元素复制到该空vector。
at	返回对vector中指定位置的元素的引用。
back	返回对vector中最后一个元素的引用。
begin	对该vector中第一个元素返回随机访问迭代器。
capacity	返回在不分配更多的存储的情况下vector可以包含的元素数。
cbegin	返回指向vector中第一个元素的随机访问常量迭代器。
cend	返回一个随机访问常量迭代器，它指向刚超过vector末尾的位置。
crbegin	返回一个指向反向vector中第一个元素的常量迭代器。
crend	返回一个指向反向vector末尾的常量迭代器。
clear	清除vector的元素。
data	返回指向vector中第一个元素的指针。
emplace	将就地构造的元素插入到指定位置的vector中。
emplace_back	将一个就地构造的元素添加到vector末尾。
empty	测试vector容器是否为空。
end	返回指向vector末尾的随机访问迭代器。
erase	从指定位置删除vector中的一个元素或一系列元素。
front	返回对vector中第一个元素的引用。
get_allocator	将对象返回到vector使用的 `allocator` 类。
insert	将一个元素或多个元素插入到指定位置的vector中。
max_size	返回vector的最大长度。
pop_back	删除vector末尾处的元素。
push_back	在vector末尾处添加一个元素。
rbegin	返回指向反向vector中第一个元素的迭代器。
rend	返回一个指向反向vector末尾的迭代器。
reserve	保留vector对象的最小存储长度。
resize	为vector指定新的大小。
shrink_to_fit	放弃额外容量。
size	返回vector中的元素数量。
swap	交换两个vector的元素。

运算符

运算符	描述
[]	返回对指定位置的vector元素的引用
=	用另一个vector的副本替换该vector中的元素

构造函数

vector();
explicit vector(const Allocator& Al);
//Al:要用于此对象的分配器类。 get_allocator 返回对象的分配器类。

explicit vector(size_type Count);
//Count:构造的vector中的元素数。

vector(size_type Count, const Type& Val);
//Val:构造的vector中的元素值。

vector(size_type Count, const Type& Val, const Allocator& Al);

vector(const vector& Right);
//Right:要成为副本的构造的中的vector。

vector(vector&& Right);

vector(initializer_list<Type> IList, const _Allocator& Al);
//IList:包含要复制的元素的 initializer_list。

template <class InputIterator>
vector(InputIterator First, InputIterator Last);
//First:要复制的元素范围内的第一个元素的位置。
//Last:要复制的元素范围外的第一个元素的位置。

template <class InputIterator>
vector(InputIterator First, InputIterator Last, const Allocator& Al);

示例

vector <int>::iterator v1_Iter, v2_Iter, v3_Iter, v4_Iter, v5_Iter, v6_Iter;

    // Create an empty vector v0
    vector <int> v0;

    // Create a vector v1 with 3 elements of default value 0
    vector <int> v1(3);

    // Create a vector v2 with 5 elements of value 2
    vector <int> v2(5, 2);

    // Create a vector v3 with 3 elements of value 1 and with the allocator
    // of vector v2
    vector <int> v3(3, 1, v2.get_allocator());

    // Create a copy, vector v4, of vector v2
    vector <int> v4(v2);

    // Create a new temporary vector for demonstrating copying ranges
    vector <int> v5(5);
    for (auto i : v5) {
        v5[i] = i;
    }

    // Create a vector v6 by copying the range v5[ first,  last)
    vector <int> v6(v5.begin() + 1, v5.begin() + 3);

成员函数用法

vector::assign

清除vector中的任何现有元素后，将原始vector中指定范围的值插入向量或将新元素或指定值的副本插入vector。

函数原型

void assign(size_type Count, const Type& Val); 
//Count：要插入vector中的元素的数量
//Val：要插入到vector中的元素的值

void assign(initializer_list<Type> IList);
//IList：包含着要插入的元素的initializer_list

template <class InputIterator> 
void assign(InputIterator First, InputIterator Last);
//First：要复制的元素范围内的第一个元素的位置
//Last：要复制的元素范围外的第一个元素的位置

示例

#include <vector>
#include <iostream>

int main()
{
	using namespace std;
	vector<int> v1, v2, v3;

	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);

	cout << "v1 = ";
	for (auto& v : v1) 
	{cout << v << " ";}
	cout << endl;
//v1 = 10 20 30 40 50

	v2.assign(v1.begin(), v1.end());
	cout << "v2 = ";
	for (auto& v : v2) 
	{cout << v << " ";}
	cout << endl;
//v2 = 10 20 30 40 50

	v3.assign(7, 4);
	cout << "v3 = ";
	for (auto& v : v3) 
	{cout << v << " ";}
	cout << endl;
//v3 = 4 4 4 4 4 4 4

	v3.assign({ 5, 6, 7 });
	for (auto& v : v3) 
	{cout << v << " ";}
//5 6 7

	cout << endl;
}

vector::at

返回对vector中指定位置的元素的引用。

函数原型

reference at(size_type _Pos);
//_Pos：要在矢量中引用的元素的下标或位置编号。

const_reference at(size_type _Pos) const;
//_Pos：要在矢量中引用的元素的下标或位置编号。

返回值：对自变量中的下标元素的引用。如果vector的大小小于at将引发异常。

如果将 at 的返回值分配给 const_reference，则无法修改矢量对象。

如果将 at 的返回值分配给 reference，则可以修改矢量对象。

示例

#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const int &i = v1.at( 0 );
   int &j = v1.at( 1 );
   cout << "The first element is " << i << endl;
//The first element is 10
   cout << "The second element is " << j << endl;
//The second element is 20
}

vector::back

返回对vector中最后一个元素的引用。

函数原型

reference back();

const_reference back() const;

返回值：vector的最后一个元素。如果vector为空，则返回值不确定。

如果将 back 的返回值分配给 const_reference，则无法修改矢量对象。

如果将 back 的返回值分配给 reference，则可以修改矢量对象。

当使用定义为 1 或 2 的 _ITERATOR_DEBUG_LEVEL 进行编译时，如果试图访问空矢量中的元素，将发生运行时错误。具体错误信息，请参见 Checked Iterators 。

示例

   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.back( );
   const int& ii = v1.front( );

   cout << "The last integer of v1 is " << i << endl;
//The last integer of v1 is 11

   i--;
   cout << "The next-to-last integer of v1 is "<< ii << endl;
//The next-to-last integer of v1 is 10

vector::begin

对该vector中第一个元素返回随机访问迭代器。

函数原型

const_iterator begin() const;

iterator begin();

返回值：发现 vector 中第一个元素或空 vector 之后的位置的随机访问迭代器。应始终将返回的值与 vector::end 进行比较以确保其有效。

如果将 begin 的返回值分配给 vector::const_iterator，则无法修改 vector 对象。

如果将 begin 的返回值分配给 vector::iterator，则可以修改 vector 对象。

示例

    vector<int> c1;
    vector<int>::iterator c1_Iter;
    vector<int>::const_iterator c1_cIter;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_Iter = c1.begin();
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;
//The vector c1 contains elements: 1 2

    cout << "The vector c1 now contains elements:";
    c1_Iter = c1.begin();
    *c1_Iter = 20;
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;
//The vector c1 now contains elements: 20 2

    // The following line would be an error because iterator is const
    // *c1_cIter = 200;

vector::capacity

返回在不分配更多的存储的情况下vector可以包含的元素数。

函数原型

size_type capacity() const;

返回值：分配给该vector的当前存储长度。

如果为成员函数 resize分配了足够的内存，它将更高效。使用成员函数 reserve 指定分配的内存量。

示例

   vector <int> v1;

   v1.push_back( 1 );
   cout << "The length of storage allocated is "
        << v1.capacity( ) << "." << endl;
//The length of storage allocated is 1.

   v1.push_back( 2 );
   cout << "The length of storage allocated is now "
        << v1.capacity( ) << "." << endl;
//The length of storage allocated is now 2.

vector::cbegin

返回const的范围中的第一个元素的迭代器。

函数原型

const_iterator cbegin() const;

返回值：一个const指向的范围或刚超出空范围末尾的位置的第一个元素的随机访问迭代器 (对于空范围， cbegin() == cend())。

由于使用 cbegin 的返回值，因此不能修改范围中的元素。

可以使用此成员函数替代 begin() 成员函数，以保证返回值为 const_iterator。它一般与 auto 类型推导关键字联合使用。

示例

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

vector::cend

返回const刚超出范围中的最后一个元素的位置的迭代器。

函数原型

const_iterator cend() const;

cend 用于测试迭代器是否超过了其范围的末尾。

可以使用此成员函数替代 end() 成员函数，以保证返回值为 const_iterator。它一般与 auto 类型推导关键字联合使用，

示例

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

vector::crbegin

返回一个指向反向vector中第一个元素的常量迭代器。

函数原型

const_reverse_iterator crbegin() const;

示例

   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;
//The first element of vector is 1.

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
//The first element of the reversed vector is 2.

vector::crend

返回一个常量迭代器，此迭代器用于发现反向矢量中最后一个元素之后的位置。

函数原型

const_reverse_iterator crend() const;

crend 用于反向 vector，正如 vector::cend 用于 vector 一样。

由于使用 crend 的返回值（适当递减），因此不能修改 vector 对象。

crend 可用于测试反向迭代器是否已到达其 vector 的末尾。

不应对 crend 返回的值取消引用。

示例

   vector <int> v1;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
//2
//1

vector::clear

清除vector的元素。

函数原型

void clear();

示例

   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "The size of v1 is " << v1.size( ) << endl;
//The size of v1 is 3
   v1.clear( );
   cout << "The size of v1 after clearing is " << v1.size( ) << endl;
//The size of v1 after clearing is 0

vector::data

返回指向vector中第一个元素的指针。

函数原型

const_pointer data() const;

pointer data();

返回一个指针，它指向vector中第一个元素或紧随空 vector 后的位置。

示例

    vector<int> c1;
    vector<int>::pointer c1 ptr;
    vector<int>::const_pointer c1_cPtr;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_cPtr = c1.data();
    for (size_t n = c1.size(); 0 < n; --n, c1_cPtr++)
    {
        cout << " " << *c1_cPtr;
    }
    cout << endl;
//The vector c1 contains elements: 1 2

    cout << "The vector c1 now contains elements:";
    c1 ptr = c1.data();
    *c1 ptr = 20;
    for (size_t n = c1.size(); 0 < n; --n, c1 ptr++)
    {
        cout << " " << *c1 ptr;
    }
    cout << endl;
//The vector c1 now contains elements: 20 2

vector::emplace

将就地构造的元素插入到指定位置的vector中。

函数原型

iterator emplace(
    const_iterator _Where,    //vector中插入第一个元素的位置。
    Type&& val);              //插入到 vector 中的元素的值。

返回值：该函数将返回一个指向 vector 中新元素的插入位置的迭代器。

任何插入操作都可能产生巨额费用。

示例

   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 10 20 30

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
//vv1[0] = 10 20 30

vector::emplace_back

将一个就地构造的元素添加到vector末尾。

函数原型

template <class... Types>
void emplace_back(Types&&... _Args);
//_args构造函数参数。 函数根据所提供的自变量来推断要调用的构造函数重载。

示例

struct obj
{
   obj(int, double) {}
};

int main()
{
   std::vector<obj> v;
   v.emplace_back(1, 3.14); // obj in created in place in the vector
}

vector::empty

如果vector为空，则为 true；如果vector不为空，则为 false。

函数原型

bool empty() const;

示例

   vector <int> v1;

   v1.push_back( 10 );

   if ( v1.empty( ) )
      cout << "The vector is empty." << endl;
   else
      cout << "The vector is not empty." << endl;

//The vector is not empty.

vector::end

返回超过末尾迭代器。如果该向量为空，则 vector::end() == vector::begin()。

函数原型

iterator end();

const_iterator end() const;

如果返回值end分配给类型的变量的const_iterator，无法修改矢量对象。

如果返回值end分配给类型的变量的iterator，可以修改矢量对象。

示例

   vector <int> v1;
   vector <int>::iterator v1_Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
      cout << *v1_Iter << endl;
//1
//2

vector::erase

从指定位置删除向量中的一个元素或一系列元素。

函数原型

iterator erase(
    const_iterator _Where);    //要从向量中移除的元素的位置。

iterator erase(
    const_iterator first,     //要从向量中移除的第一个元素的位置。
    const_iterator last);     //紧接要从向量中移除的最后一个元素的位置。

返回值：一个迭代器，它指定已移除的任何元素之外保留的第一个元素或指向向量末尾的指针（若此类元素不存在）。

示例

   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );
   v1.push_back( 40 );
   v1.push_back( 50 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 10 20 30 40 50

   v1.erase( v1.begin( ) );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 20 30 40 50

   v1.erase( v1.begin( ) + 1, v1.begin( ) + 3 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 20 50

vector::front

返回对vector对象中第一个元素的引用。如果vector为空，则返回值不确定。

函数原型

reference front();

const_reference front() const;

如果将 front 的返回值分配给 const_reference，则无法修改vector对象。

如果将 front 的返回值分配给 reference，则可以修改vector对象。

示例

   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.front( );
   const int& ii = v1.front( );

   cout << "The first integer of v1 is "<< i << endl;
   // by incrementing i, we move the front reference to the second element
   i++;
   cout << "Now, the first integer of v1 is "<< i << endl;

vector::get_allocator

返回用于构造vector的分配器对象的一个副本。

函数原型

Allocator get_allocator() const;

示例

using namespace std;
   // 下面几行声明使用默认分配器的对象。
   vector<int> v1;
   vector<int, allocator<int> > v2 = vector<int, allocator<int> >(allocator<int>( )) ;

   // v3将使用与v1相同的分配器类
   vector <int> v3( v1.get_allocator( ) );

   vector<int>::allocator_type xvec = v3.get_allocator( );
   // 现在可以调用vec使用的分配器类上的函数

vector::insert

将一个、多个或一系列元素插入到指定位置的vector中。

函数原型

iterator insert(
    const_iterator _Where,            //向量中插入第一个元素的位置。
    const Type& val);                 //插入到向量中的元素的值。

iterator insert(
    const_iterator _Where,            //向量中插入第一个元素的位置。
    Type&& val);                      //插入到向量中的元素的值。

void insert(
    const_iterator _Where,            //向量中插入第一个元素的位置。
    size_type count,                  //插入向量中的元素数目。
    const Type& val);                 //插入到向量中的元素的值。

template <class InputIterator>
void insert(
    const_iterator _Where,            //向量中插入第一个元素的位置。
    InputIterator first,              //要复制的范围元素中的第一个元素的位置。
    InputIterator last);              //要复制的元素范围以外的第一个元素的位置。

前两个 insert 函数返回一个指定新元素插入到vector的位置的迭代器。

示例

   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 10 20 30

   v1.insert( v1.begin( ) + 1, 40 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 10 40 20 30

   v1.insert( v1.begin( ) + 2, 4, 50 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 10 40 50 50 50 50 20 30

   const auto v2 = v1;
   v1.insert( v1.begin( )+1, v2.begin( )+2, v2.begin( )+4 );
   cout << "v1 =";
   for (Iter = v1.begin( ); Iter != v1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;
//v1 = 10 50 50 40 50 50 50 50 20 30

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.insert( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
//vv1[0] = 10 50 50 40 50 50 50 50 20 30

vector::max_size

返回vector的最大长度。

函数原型

size_type max_size() const;

示例

vector <int> v1;
   vector <int>::size_type i;

   i = v1.max_size( );
   cout << "The maximum possible length of the vector is " << i << "." << endl;

vector::pop_back

删除vector末尾处的元素。

函数原型

void pop_back();

示例

有关代码示例，请参阅 vector::push_back()。

vector::push_back

在vector末尾处添加一个元素。

函数原型

void push_back(const T& Val);

void push_back(T&& Val);
//val：要赋给添加到矢量末尾处的元素的值。

示例

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(10 + i);
    }

    cout << "vector data: " << endl;
    print_collection(v);

    // pop_back() until it's empty, printing the last element as we go
    while (v.begin() != v.end()) {
        cout << "v.back(): "; print_elem(v.back()); cout << endl;
        v.pop_back();
    }
}
//vector data:
//  10 elements: (10) (11) (12) (13) (14) (15) (16) (17) (18) (19)
//v.back(): (19)
//v.back(): (18)
//v.back(): (17)
//v.back(): (16)
//v.back(): (15)
//v.back(): (14)
//v.back(): (13)
//v.back(): (12)
//v.back(): (11)
//v.back(): (10)

vector::rbegin

返回指向反向vector中第一个元素的迭代器。

函数原型

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

如果将 rbegin 的返回值分配给 const_reverse_iterator，则无法修改矢量对象。

如果将 rbegin 的返回值分配给 reverse_iterator，则可以修改矢量对象。

示例

   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;
//The first element of vector is 1.

   v1_rIter = v1.rbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
//The first element of the reversed vector is 2.

vector::rend

返回一个迭代器，此迭代器用于发现反向vector中最后一个元素之后的位置。

函数原型

const_reverse_iterator rend() const;
reverse_iterator rend();

rend 用于反向vector，正如 end 用于vector一样。

如果将 rend 的返回值分配给 const_reverse_iterator，则无法修改vector对象。如果将 rend 的返回值分配给 reverse_iterator，则可以修改vector对象。

rend 可用于测试反向迭代器是否已到达其vector末尾。

不应对 rend 返回的值取消引用。

示例

   vector <int> v1;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
//2
//1

vector::reserve

为vector对象保留最小的存储长度，必要时为其分配空间。

函数原型

void reserve(size_type count);
//count:要分配给向量的最小存储长度。

示例

   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
//Current capacity of v1 = 1

   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
//Current capacity of v1 = 20

vector::resize

为vector指定新的大小。

函数原型

void resize(size_type Newsize);
//Newsize:矢量的新大小。

void resize(size_type Newsize, Type Val);
//val:新大小大于旧大小时添加至矢量的新元素的初始化值。 如果省略该值，则新对象将使用其默认构造函数。

如果容器的大小小于请求的大小Newsize，元素添加到vector，直到它达到请求的大小。如果容器的大小大于请求的大小，最接近容器末尾的元素将被删除之前该容器达到大小Newsize。如果容器的当前大小与请求的大小相同，则不采取任何操作。

示例

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }
    cout << endl;
}

void printvstats(const vector<int>& v) {
    cout << "   the vector's size is: " << v.size() << endl;
    cout << "   the vector's capacity is: " << v.capacity() << endl;
    cout << "   the vector's maximum size is: " << v.max_size() << endl;
}

int main()
{
    
    vector<int> v;

    // 显示vector的信息.
    cout << endl << "After declaring an empty vector:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);
   //After declaring an empty vector:
   //the vector's size is: 0
   //the vector's capacity is: 0
   //the vector's maximum size is: 1073741823
   //the vector's contents:

    // 将一个元素添加到vector尾部.
    v.push_back(-1);
    cout << endl << "After adding an element:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);
   //After adding an element:
   //the vector's size is: 1
   //the vector's capacity is: 1
   //the vector's maximum size is: 1073741823
   //the vector's contents: -1

    for (int i = 1; i < 10; ++i) {
        v.push_back(i);
    }
    cout << endl << "After adding 10 elements:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);
   //After adding 10 elements:
   //the vector's size is: 10
   //the vector's capacity is: 13
   //the vector's maximum size is: 1073741823
   //the vector's contents: -1 1 2 3 4 5 6 7 8 9

    v.resize(6);
    cout << endl << "After resizing to 6 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);
   //After resizing to 6 elements without an initialization value:
   //the vector's size is: 6
   //the vector's capacity is: 13
   //the vector's maximum size is: 1073741823
   //the vector's contents: -1 1 2 3 4 5

    v.resize(9, 999);
    cout << endl << "After resizing to 9 elements with an initialization value of 999:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);
   //After resizing to 9 elements with an initialization value of 999:
   //the vector's size is: 9
   //the vector's capacity is: 13
   //the vector's maximum size is: 1073741823
   //the vector's contents: -1 1 2 3 4 5 999 999 999

    v.resize(12);
    cout << endl << "After resizing to 12 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);
   //After resizing to 12 elements without an initialization value:
   //the vector's size is: 12
   //the vector's capacity is: 13
   //the vector's maximum size is: 1073741823
   //the vector's contents: -1 1 2 3 4 5 999 999 999 0 0 0

    v.reserve(1000);
    cout << endl << "After vector::reserve(1000):" << endl;
    printvstats(v);
   //After vector::reserve(1000):
   //the vector's size is: 12
   //the vector's capacity is: 1000
   //the vector's maximum size is: 1073741823

    v.resize(2000);
    cout << endl << "After vector::resize(2000):" << endl;
    printvstats(v);
   //After vector::resize(2000):
   //the vector's size is: 2000
   //the vector's capacity is: 2000
   //the vector's maximum size is: 1073741823
}

vector::shrink_to_fit

放弃额外容量。

函数原型

void shrink_to_fit();

示例

   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
//Current capacity of v1 = 1

   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
//Current capacity of v1 = 20

   v1.shrink_to_fit();
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
//Current capacity of v1 = 1

vector::size

返回vector中的元素数量。

函数原型

size_type size() const;

示例

   vector <int> v1;
   vector <int>::size_type i;

   v1.push_back( 1 );
   i = v1.size( );
   cout << "Vector length is " << i << "." << endl;
//Vector length is 1.

   v1.push_back( 2 );
   i = v1.size( );
   cout << "Vector length is now " << i << "." << endl;
//Vector length is now 2.

vector::swap

交换两个vector的元素。

函数原型

void swap(
    vector<Type, Allocator>& right);    //vector，提供要交换的元素

friend void swap(
    vector<Type, Allocator>& left,      //其元素将要与vector right交换。
    vector<Type, Allocator>& right);    //vector right的元素将要同vector left的元素交换。

示例

   vector <int> v1, v2;

   v1.push_back( 1 );
   v1.push_back( 2 );
   v1.push_back( 3 );

   v2.push_back( 10 );
   v2.push_back( 20 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
   cout << endl;
//The number of elements in v1 = 3
//The number of elements in v2 = 2

   v1.swap( v2 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
//The number of elements in v1 = 2
//The number of elements in v2 = 3

vector具体常用的函数的就是上面这些了，也都包括有例子和函数原型，如果有问题欢迎大佬指出，

C++STL容器之Vector详解

总结

成员

typedef

成员函数

运算符

构造函数

成员函数用法

vector::assign

vector::at

vector::back

vector::begin

vector::capacity

vector::cbegin

vector::cend

vector::crbegin

vector::crend

vector::clear

vector::data

vector::emplace

vector::emplace_back

vector::empty

vector::end

vector::erase

vector::front

vector::get_allocator

vector::insert

vector::max_size

vector::pop_back

vector::push_back

vector::rbegin

vector::rend

vector::reserve

vector::resize

vector::shrink_to_fit

vector::size

vector::swap

PHP进阶学习之依赖注入与Ioc容器详解

STL之vector详解

C++STL之set容器

详解C++ STL vector容器访问元素的几种方式

C++STL之Vector向量详解,用法和例子 一起学习 一起加油

C++ STL容器详解之红黑树部分模拟实现

C++入门之vector的底层实现详解

C++入门之vector使用详解

C++：[STL]详解STL之sequence container的操作及使用(vector)

Collection容器家族(Vector讲解及Stack源码详解）

C++STL之Vector向量详解,用法和例子一起学习一起加油