C++ STL它vector详细解释

Vectors

   vector它是C++标准模板库部分，它是一种多用途，你可以使用各种数据结构和算法的模板类和库。

vector其原因被认为是一个容器。因为它可以被存储为各种类型的对象作为容器。一般来讲。vector个可以存放随意类型的动态数组。可以添加和压缩数据。

为了可以使用vector。必须在你的头文件里包括以下的代码：#include <vector>

构造函数。









  Vectors 包括着一系列连续存储的元素,其行为和数组类似。訪问Vector中的随意元素或从末尾加入元素都能够在常量级时间复杂度内完毕，而查找特定值的元素所处的位置或是在Vector中插入元素则是线性时间复杂度。









函数列表例如以下:

Constructors 构造函数 

Operators 对vector进行赋值或比較 

assign() 对Vector中的元素赋值 

at() 返回指定位置的元素 

back() 返回最末一个元素 

begin() 返回第一个元素的迭代器 

capacity() 返回vector所能容纳的元素数量(在不又一次分配内存的情况下） 

clear() 清空全部元素 

empty() 推断Vector是否为空（返回true时为空） 

end() 返回最末元素的迭代器(译注:实指向最末元素的下一个位置) 

erase() 删除指定元素 

front() 返回第一个元素 

get_allocator() 返回vector的内存分配器 

insert() 插入元素到Vector中 

max_size() 返回Vector所能容纳元素的最大数量（上限） 

pop_back() 移除最后一个元素 

push_back() 在Vector最后加入一个元素 

rbegin() 返回Vector尾部的逆迭代器 

rend() 返回Vector起始的逆迭代器 

reserve() 设置Vector最小的元素容纳数量 

resize() 改变Vector元素数量的大小 

size() 返回Vector元素数量的大小 

swap() 交换两个Vector





////////////////////////////////////////////////////////////////////////////

                               函数具体说明

构造函数

语法: 

vector();

vector( size_type num, const TYPE &val );

vector( const vector &from );

vector( input_iterator start, input_iterator end );









C++ Vectors能够使用下面随意一种參数方式构造: 

无參数 - 构造一个空的vector, 

数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector 

vector(from) - 构造一个与vector from 同样的vector 

迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间). 

举例,以下这个实例构造了一个包括5个值为42的元素的Vector

vector<int> v1( 5, 42 );

运算符

语法: 

v1 == v2

v1 != v2

v1 <= v2

v1 >= v2

v1 < v2

v1 > v2 

v[]

C++ Vectors可以使用标准运算符: ==, !=, <=, >=, <, 和 >. 要訪问vector中的某特定位置的元素可以使用 [] 操作符. 

两个vectors被觉得是相等的,假设: 

它们具有同样的容量 

全部同样位置的元素相等. 

vectors之间大小的比較是依照词典规则. 









assign函数 





语法: 

void assign( input_iterator start, input_iterator end );

void assign( size_type num, const TYPE &val );

assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值曾经的内容.









at函数 

语法: 

TYPE at( size_type loc );

at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 由于它不会让你去訪问到Vector内越界的元素. 比如, 考虑以下的代码:

vector<int> v( 5, 1 );

for( int i = 0; i < 10; i++ ) {

cout << "Element " << i << " is " << v[i] << endl;

}

这段代码訪问了vector末尾以后的元素,这将可能导致非常危急的结果.下面的代码将更加安全: 

vector<int> v( 5, 1 );

for( int i = 0; i < 10; i++ ) {

cout << "Element " << i << " is " << v.at(i) << endl;

}

代替试图訪问内存里非法值的作法,at() 函数可以辨别出訪问是否越界并在越界的时候抛出一个异常out_of_range.









back 函数 

语法: 

TYPE back();

back() 函数返回当前vector最末一个元素的引用.比如: 

vector<int> v;

for( int i = 0; i < 5; i++ ) {

v.push_back(i);

}

cout << "The first element is " << v.front() 

     << " and the last element is " << v.back() << endl;

这段代码产生例如以下结果:

The first element is 0 and the last element is 4









begin 函数 

语法: 

iterator begin();

begin()函数返回一个指向当前vector起始元素的迭代器.比如,以下这段使用了一个迭代器来显示出vector中的全部元素:

vector<int> v1( 5, 789 );

vector<int>::iterator it;

for( it = v1.begin(); it != v1.end(); it++ )

cout << *it << endl;









capacity 函数 

语法: 

size_type capacity();

capacity() 函数 返回当前vector在又一次进行内存分配曾经所能容纳的元素数量.









clear 函数 

语法: 

void clear();

clear()函数删除当前vector中的全部元素.









empty 函数 

语法: 

bool empty();

假设当前vector没有容纳不论什么元素,则empty()函数返回true,否则返回false.比如,下面代码清空一个vector,并依照逆序显示全部的元素:

vector<int> v;

for( int i = 0; i < 5; i++ ) {

    v.push_back(i);

}

while( !v.empty() ) {

    cout << v.back() << endl;

    v.pop_back();

}









end 函数 

语法: 

iterator end();

end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,假设你要訪问末尾元素,须要先将此迭代器自减1.









erase 函数 

语法: 

iterator erase( iterator loc );

iterator erase( iterator start, iterator end );

erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的全部元素.返回值是指向删除的最后一个元素的下一位置的迭代器.比如:

// 创建一个vector,置入字母表的前十个字符

vector<char> alphaVector;

for( int i=0; i < 10; i++ )

    alphaVector.push_back( i + 65 );

int size = alphaVector.size();





vector<char>::iterator startIterator;

vector<char>::iterator tempIterator;





for( int i=0; i < size; i++ )

{

    tartIterator = alphaVector.begin();

    alphaVector.erase( startIterator );





    // Display the vector

    for( tempIterator = alphaVector.begin(); tempIterator != alphaVector.end(); tempIterator++ )

    cout << *tempIterator;

    cout << endl;

} 

这段代码将会显演示样例如以下输出:





BCDEFGHIJ

CDEFGHIJ

DEFGHIJ

EFGHIJ

FGHIJ

GHIJ

HIJ

IJ

J





front 函数 

语法: 

TYPE front();

front()函数返回当前vector起始元素的引用









get_allocator 函数 

语法: 

allocator_type get_allocator();

get_allocator() 函数返回当前vector的内存分配器.在STL里面一般不会调用new或者alloc来分配内存,并且通过一个allocator对象的相关方法来分配.

演示样例:vector<int>v3( 3, 1, v2.get_allocator( ));//把V2的内存分配器作为一个參数參与构造V3。

这样，它们两个用一个内存分配器了。

insert 函数 

语法: 

iterator insert( iterator loc, const TYPE &val );

void insert( iterator loc, size_type num, const TYPE &val );

void insert( iterator loc, input_iterator start, input_iterator end );

insert() 函数有下面三种使用方法: 

在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器, 

在指定位置loc前插入num个值为val的元素 

在指定位置loc前插入区间[start, end)的全部元素 . 

举例: 

//创建一个vector,置入字母表的前十个字符

vector<char> alphaVector;

for( int i=0; i < 10; i++ )

alphaVector.push_back( i + 65 );

//插入四个C到vector中

vector<char>::iterator theIterator = alphaVector.begin();

alphaVector.insert( theIterator, 4, 'C' );

//显示vector的内容

for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )

cout << *theIterator;

这段代码将显示: 

CCCCABCDEFGHIJ









max_size 函数 

语法: 

size_type max_size();

max_size() 函数返回当前vector所能容纳元素数量的最大值(译注:包含可又一次分配内存). 









pop_back 

语法: 

void pop_back();

pop_back()函数删除当前vector最末的一个元素,比如:





vector<char> alphaVector;

for( int i=0; i < 10; i++ )

    alphaVector.push_back( i + 65 );





int size = alphaVector.size();

vector<char>::iterator theIterator;

for( int i=0; i < size; i++ ) {

alphaVector.pop_back();

for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )

      cout << *theIterator;

cout << endl;

}





这段代码将显示下面输出:





ABCDEFGHI

ABCDEFGH

ABCDEFG

ABCDEF

ABCDE

ABCD

ABC

AB

A





push_back 函数 

语法: 

void push_back( const TYPE &val );

push_back()加入值为val的元素到当前vector末尾









rbegin 函数 

语法: 

reverse_iterator rbegin();

rbegin函数返回指向当前vector末尾的逆迭代器.(译注:实际指向末尾的下一位置,而其内容为末尾元素的值,详见逆代器相关内容)

演示样例:

vector<int>v1;

for(int i=1;i<=5;i++)

{

    v1.push_back(i);

}

vector<int>::reverse_iterator pos;

pos=v1.rbegin();

cout<<*pos<<" ";

pos++;

cout<<*pos<<endl;

输出结果为:5 4









rend 函数 

语法: 

reverse_iterator rend();

rend()函数返回指向当前vector起始位置的逆迭代器. 

演示样例:

vector<int>v1;

for(int i=1;i<=5;i++)

{

    v1.push_back(i);

}

vector<int>::reverse_iterator pos;

pos=v1.rend();

pos--;

cout<<*pos<<" ";

pos--;

cout<<*pos<<endl;

输出结果为:1 2









reserve 函数 

语法: 

void reserve( size_type size );

reserve()函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)









resize 函数 

语法: 

void resize( size_type size, TYPE val );

resize() 函数改变当前vector的大小为size,且对新创建的元素赋值val





resize 与reserve的差别

    reserve是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当增加新的元素时。须要用push_back()/insert()函数。

    resize是改变容器的大小。而且创建对象。因此，调用这个函数之后，就能够引用容器内的对象了，因此当增加新的元素时。用operator[]操作符，或者用迭代器来引用元素对象。再者，两个函数的形式是有差别的。reserve函数之后一个參数。即须要预留的容器的空间；resize函数能够有两个參数。第一个參数是容器新的大小。第二个參数是要增加容器中的新元素，假设这个參数被省略，那么就调用元素对象的默认构造函数。

初次接触这两个接口或许会混淆，事实上接口的命名就是对功能的绝佳描写叙述，resize就是又一次分配大小，reserve就是预留一定的空间。这两个接口即存在区别，也有共同点。

以下就它们的细节进行分析。

     为实现resize的语义，resize接口做了两个保证：

            一是保证区间[0, new_size)范围内数据有效，假设下标index在此区间内。vector[indext]是合法的。

二是保证区间[0, new_size)范围以外数据无效，假设下标index在区间外。vector[indext]是非法的。

reserve仅仅是保证vector的空间大小(capacity)最少达到它的參数所指定的大小n。在区间[0, n)范围内，假设下标是index，vector[index]这样的訪问有可能是合法的。也有可能是非法的，视详细情况而定。

     resize和reserve接口的共同点是它们都保证了vector的空间大小(capacity)最少达到它的參数所指定的大小。

因两接口的源码相当精简，以至于能够在这里贴上它们：

void resize(size_type new_size) { resize(new_size, T()); }

void resize(size_type new_size, const T& x) {

    if (new_size < oldsize) 

      erase(oldbegin + new_size, oldend); // erase区间范围以外的数据，确保区间以外的数据无效

    else

      insert(oldend, new_size - oldsize, x); // 填补区间范围内空缺的数据，确保区间内的数据有效

演示样例:

#include<iostream>

#include<vector>

using namespace std;

void main()

{

    vector<int>v1;

for(int i=1;i<=3;i++)

{

    v1.push_back(i);

}

v1.resize(5,8);//多出的两个空间都初始化为8。

for(i=0;i<v1.size();i++)//resize与reserver并不会删除原先的元素以释放空间

{

     cout<<v1[i]<<" ";

}

cout<<endl;

v1.reserve(7);// 新元素还没有构造,

    for(i=0;i<7;i++)

{

     cout<<v1[i]<<" ";//当i>4,此时不能用[]訪问元素 

}

cout<<endl;

cout<<v1.size()<<endl;

cout<<v1.capacity()<<endl;

}

输出结果为:

1 2 3 8 8

1 2 3 8 8 -842150451 -842150451

5

7









size 函数 





语法: 

size_type size();

size() 函数返回当前vector所容纳元素的数目 









swap 函数 

语法: 

void swap( vector &from );

swap()函数交换当前vector与vector from的元素

演示样例:

     vector<int>v1,v2;

     for(int i=1;i<=3;i++)

     {

v1.push_back(i);

        v2.push_back(i);

     }

v2.push_back(4);

     v2.push_back(5);

     v1.swap(v2);

     for(int j=0;j<v1.size();j++)

     {

cout<<v1[j]<<" ";

     }

     cout<<endl;

     for(int k=0;k<v2.size();k++)

     {

cout<<v2[k]<<" ";

     }

     cout<<endl;

的输出是:

1 2 3 4 5

1 2 3

版权声明：本文博客原创文章，博客，未经同意，不得转载。