【STL】verctor的简单剖析以及各种函数的实现

概述

vector其实和array数组挺像的，但是vector之所以存在的原因是：

vector是动态空间，随着元素的增加，它的内部机制会自行扩建空间以容纳新的元素；而array是静态空间，一旦配置大小就不能改变了；

vector的数据结构

vector有三个成员变量。

T* _start; //表示目前使用的空间头
T* _finish;//表示目前是的空间尾
T* _end_of_storage; //表示可用的空间尾。
//其实就是size大小和容量的大小

vector的构造和内存管理

所谓的动态增加容量，并不是在原来的空间后面连接新的空间，而是以原大小的两倍，另外配置一块空间，然后将原内容拷贝过来，然后在原内容之后构造新的内容，释放原来的空间，因此，对vector的操作，一旦引起空间重新配置的话，迭代器会失效。

vector的构造函数

//（1）默认空的构造函数
（1）explicit vector ( const Allocator& = Allocator() );

//（2）构造n个对象，对象值为value的vector
（2）explicit vector ( size_type n, const T& value= T(), const Allocator& = Allocator() );

//（3）范围构造，可以使array，也可是其他vector的迭代器
(3)template <class InputIterator>
vector ( InputIterator first, InputIterator last, const Allocator& = Allocator() );

//（4）拷贝构造函数
(4)vector ( const vector<T,Allocator>& x );

测试

// constructors used in the same order as described above:
vector<int> first;    // empty vector of ints（1）
vector<int> second (4,100);  //(2) four ints with value 100
vector<int> third (second.begin(),second.end());  //(3) iterating through second
vector<int> fourth (third);                       // (4)a copy of third

// the iterator constructor can also be used to construct from arrays:(3)
int myints[] = {16,2,77,29};
vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );
//16 2 77 29

Iterators函数

注：迭代器可能会失效，区间是左闭右开的。

begin和end函数，指向vector的起始位置和末尾

rbegin和rend函数，相反。

Capacity函数

(1)size函数

size_type size() const;//返回vector的大小，有多少对象

size_type max_size () const; //返回vector的最大值，一般用不到

size_type capacity () const; //返回vector的容量大小，一般大于等于size

(2)reserve函数和resize函数

void resize ( size_type sz, T c = T() );

resize函数时对vector对象进行扩充或者切割，sz只能在capacity范围内改变，如果sz大于size的话， 用c进行扩充，如果sz小于size的话，进行切割，

void reserve ( size_type n );

reserve函数请求改变vector的capacity大小的，

Element access:函数

元素操作方位函数：

reference operator[] ( size_type n );
const_reference operator[] ( size_type n ) const;

const_reference at ( size_type n ) const;
reference at ( size_type n );

at会进行边界检查而operator []函数不会。

front函数，返回第一个元素

back函数，返回最后一个元素

Modifiers:函数

push_back和pop_back 函数

void push_back ( const T& x );
//Add element at the end (public member function)

void pop_back ( );
//Delete last element (public member function)

insert函数

insert函数：是在pos位置之前插入元素。

(1)iterator insert ( iterator position, const T& x );
(2)  void insert ( iterator position, size_type n, const T& x );
(3)template <class InputIterator>
void insert ( iterator position, InputIterator first, InputIterator last );

(1) 在pos位置插入一个x，

(2)在pos位置之前插入n个x

(3)在pos位置之前插入一个范围[first, last);

实现

insert函数先看剩余的容量是否够能够插入新的元素，

剩余容量够：计算pos位置之后的元素个数num是否大于新增个数n

(1)大于n：先把pos位置最后的n个元素拷贝到未初始化区域，再将pos之后的元素num-n拷贝到初始化区域的末尾，最后插入元素

(2)小于n：先将n -nums 个新元素填充到pos+nums后面

再将pos后面的num个元素拷贝到pos+n后面，最后填充value。

剩余容量不够：进行重新配置空间，然后再进行插入元素。

为什么这样做呢？因为效率问题，未初始化区域的初始和初始化区域调用不同的函数进行拷贝，初始化。

测试

vector<int> myvector (3,100); // 100 100 100
vector<int>::iterator it;

it = myvector.begin();
it = myvector.insert ( it , 200 ); //200 100 100 100

//注：it为上一个insert函数的返回值，
myvector.insert (it,2,300);
// 300 300 200 100 100 100

//迭代器失效
// "it" no longer valid, get a new one:
it = myvector.begin();

vector<int> anothervector (2,400);
myvector.insert (it+2,anothervector.begin(),anothervector.end());
// 300 300 400 400 200 100 100 100

int myarray [] = { 501,502,503 };
myvector.insert (myvector.begin(), myarray, myarray+3);
// 501 502 503 300 300 400 400 200 100 100 100

erase函数

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

swap函数

交换两个vector对象

void swap ( vector<T,Allocator>& vec );

assign函数

重新改变vector的对象内容

template <class InputIterator>
void assign ( InputIterator first, InputIterator last );
void assign ( size_type n, const T& u );

clear函数

删除所有的元素，size为0；

void clear ( );