C++標准庫之vector（各函數及其使用全）

原創作品，轉載請注明出處：http://www.cnblogs.com/shrimp-can/p/5280566.html

iterator類型：

iterator:到value_type的訪問，value_type是模板的類型

const_iterator:到const value_type的訪問

reverse_iterator:reverse_iterator<iterator>

const_reverse_iterator:reverse_iterator<const_iterator>

其中我們常用的是iterator。

函數：

一、構造、賦值相關函數：

1.構造函數：

explicit vector (const allocator_type& alloc = allocator_type());	默認構造函數，空容器
explicit vector (size_type n); vector (size_type n, const value_type& val, const allocator_type& alloc = allocator_type());	用n個val填充容器，含一個參數的是C++11定義的
template <class InputIterator> vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());	范圍構造，[first,last)這么多個，並且填充
vector (const vector& x); vector (const vector& x, const allocator_type& alloc);	拷貝構造，兩個參數的是C++11
vector (vector&& x); vector (vector&& x, const allocator_type& alloc);	C++11
vector (initializer_list<value_type> il, const allocator_type& alloc = allocator_type());	C++11

如：

  std::vector<int> first;                                // empty vector of ints
  std::vector<int> second (4,100);                       // four ints with value 100
  std::vector<int> third (second.begin(),second.end());  // iterating through second
  std::vector<int> fourth (third);

2.=操作：vector& operator= (const vector& x);

可以將一個vector通過=符號賦給另一個vector

如

  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';

輸出為：

Size of foo: 0
Size of bar: 3

二、Iterator操作相關函數：

1.begin:iterator begin();

             const_iterator begin() const;

返回指向第一個元素的iterator指針

2.end：用法與begin同，通常是一起使用來遍歷容器中的元素

返回指向最后一個元素再后面一個的iterator指針

3.rbegin：reverse_iterator rbegin();

              const_reverse_iterator rbegin() const;

返回指向最后一個元素的reverse_iterator指針

4.rend：用法與rbegin相同

返回指向第一個元素前面一個元素的reverse_iterator指針，通常與rbegin一起使用來反向遍歷容器

5.cbegin、cend返回值類型為const_iterator，功能同begin、end

6.crbegin、crend返回值類型為const_reverse_iterator，功能同crbegin、crend

常用來遍歷表，例如：

vector<int>::iterator Iter;

vector<int> c;

for(Iter=c.begin();Iter!=c.end();Iter++)

{}

 

三、capacity相關函數

1.size:size_type size() const;

容器中元素個數。c.size();

2.max_size():size_type max_size() const;

返回最大容量。c.maxsize();

3.resize：void resize (size_type n, value_type val = value_type());

改變容器可以容納元素的個數為n。如果n小於當前的容器大小，則保留前面n個元素，移除后面的。如果n大於當前容器大小，就擴展容器。value是初始值，如果n大於當前容器大小，則新增加的元素的值為value，若value省略，會自動調用一個默認值。

std::vector<int> c;

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

     c.push_back(i);

c.resize(5);

c.resize(8,10);

c.resize(12);

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

    std::cout<<c[i]<<"  "；

結果為：1  2  3  4  5  10  10  10  0  0  0  0

4.capacity:size_type capacity() const;

當前分配給容器的存儲空間大小（元素個數），這並不限制容器的擴展，理論限制容器擴展大小是max_size的值

5.empty:bool empty() const;

返回容器是否為空while(!c.empty()){sum+=c.back();
c.pop_back();}

6.reserve:void reserve (size_type n);

使得capacity至少能容納n個元素。

7.shrink_to_fit（C++11）:void shrink_to_fit();

減小capacity，使其與容器大小相同

 

四、元素訪問相關函數

1.[ ]操作:獲取特定位置的元素。c[i]；

2.at:reference at (size_type n);

       const_reference at (size_type n) const;

返回位置n處的元素。c.at(i),與c[i]差不多

3.front:reference front();

               const_reference front() const;

返回容器中的第一個元素。c.front();

4.back:reference back()

        const_reference back() const;

返回容器中最后一個元素。c.back();

5.data（C++11）:value_type* data() noexcept;

           const value_type* data() const noexcept;

返回一個指向容器中數組的指針c.data()

int *p=c.data();

*p=10;

++p;

*p=20;

p[2]=100;

則c中存儲的前面三個數據為10、20、100

 

五、更新操作

1.assign：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);（C++11）

  給容器分配新的內容，並替換當前內容，同時修改大小,val為初始值

std::vector<int>first;

std::vector<int>second;

std::vector<int>third;

first.assign(7,100);

std::vector<int>::iterator it;

it=first.begin()+1;

second.assign(it,first.end()-1);

int myints[]={1776,7,4};

third.assign(myints,myints+3);

std::cout<<int(first.size())<<"  "<<int (second.size())<<"  "<<int (third.size())<<endl;

結果為：7  5  3

2.push_back: void push_back (const value_type& val);

在容器最后增加一個新的元素。c.push_back(n)

3.pop_back:void pop_back();

移除最后一個元素。c.pop_back()

4.insert:iterator insert(iterator position,const value_type& val)：在position處插入元素val

             void insert(iterator position,size_type n,const value_type& val):在position處插入n個元素，插入的元素值初始化為val

             void insert(iterator position,InputIterator first,InputIterator last):在position處插入數組中從first到last的元素

vector<int> c(3,100);

vector<int>::iterator it;

it=c.begin();

it=c.insert(it,200);

c.insert(it,2,300);

it=c.begin();

vector<int> d(2,400);

c.insert(it+2,d.begin(),d.end());

int s[]={501,502,503};

c.insert(c.begin(),s,s+3);

此時c中元素為：501  502  503  300  300  400  400  200  100  100  100

5.erase：iterator erase(iterator position):刪除position處的元素

             iterator erase(iterator first,iterator last)：刪除first到last的元素

std::vector<int> myvector;
for (int i=1; i<=10; i++) myvector.push_back(i);
myvector.erase (myvector.begin()+5);
myvector.erase (myvector.begin(),myvector.begin()+3);
std::cout << "myvector contains:";
for (unsigned i=0; i<myvector.size(); ++i)
  std::cout << ' ' << myvector[i];

結果為：4  5  7  8  9  10

6.swap：void swap(vector &x)

交換兩個容器的內容,兩個容器中的元素不一定要相等。c.swap(d);

7.clear：void clear():清楚容器中的所有元素。c.clear();

8.emplace：iterator emplace(const_iterator position,args&& args):在position處插入一個新的元素。

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

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

myvector.emplace ( it, 200 );

myvector.emplace ( myvector.end(), 300 );

容器中元素為：10  200  100  20  30  300

9.emplace_back：void emplace_back(args&& args):在最后插入一個元素

 

六、分配器

allocator_type get_allocator() const:給容器分配空間

std::vector<int> myvector;
  int * p;
  unsigned int i;
  p = myvector.get_allocator().allocate(5);
  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';
  for (i=0; i<5; i++) myvector.get_allocator().destroy(&p[i]);
  myvector.get_allocator().deallocate(p,5)

七、重載函數

1.重載了操作符"=="  '!='  '<'  '<='  '>'  '>=':對於==來說，首先比較它們的大小，若size相等，則依次比較元素；對於其他運算符，依次比較元素。c==d;

參考：http://www.cplusplus.com/reference/vector/vector/