c++序列式容器之vector

0.vector源代码

 

// alloc 是SGI STL的空间配置器
template<class T,class Alloc=alloc>
class vector{
   public:
     //vector的嵌套型别定义
     typedef  T             value_type;
     typedef  value_type*   pointer;
     typedef  value_type*   iterator;
     typedef  value_type*   reference;
     typedef  size_t        size_type;
     typedef  ptrdiff_t     difference_type; 
   protected:
     //simple_alloc 是SGI STL的空间配置器
     typedef simple_alloc<value_type,Alloc> data_allocator;
     iterator start;//表示目前使用空间的头
     iterator finish;//表示目前使用空间的尾
     iterator end_of_storage;//表示目前可用空间的尾

     void insert_aux(iterator position,const T& x);
     void deallocate(){
         if(start)
            data_allocator::deallocate(start,end_of_storage-start);
     }

     void fill_initialize(size_type n,const T& value)
     {
         start=allocate_and_fill(n,value);
         finish=start+n;
         end_of_storage=finsih;
     }

  public:
     iterator begin(){return start;}
     iterator end(){return finish;}
     size_type size() const {return size_type(end()-begin());}
     size_type capacity() const {return size_type(end_of_storage-begin());}
     bool empty() const {return begin()==end();}
     reference operator[](size_type n) {return *(begin()+n);}

     vector():start(0),finish(0),end_of_storage(0){}
     vector(size_type n,const T& value){fill_initialize(n,value);}
     vector(int n,const T& value){fill_initialize(n,value);}
     vector(long n,const T& value){fill_initialize(n,value);}
     explicit  vector(size_type n){fill_initialize(n,T());} 

     ~vector(){
         destroy(start,finish);
         deallocate();
     }

     reference front(){return *begin();}//第一个元素
     reference back() {return *(end()-1);}//最后一个元素
     void push_back(const T& x){//将元素插入至最尾端
         if(finish!=end_of_storage){
             construct(finish,x);
             ++finish;
         }
         else
            insert_aux(end(),x);
     }

     void pop_back(){//将最尾端元素取出
         --finish;
         destroy(finish);//全局函数
     }

     iterator erase(iterator position){//清除某位置上的元素
         if(position+1 !=end)
         {
            copy(position+1,finish,position);//后续元素往前移动
         }
         --finish;
         destroy(finish);
         return position;
     }

     void resize(size_type new_size,const T& x)
     {
         if(new_size<size())
             erase(begin()+new_size,end());
         else
             insert(end(),new_size-size(),x);
     }
     void resize(size_type new_size){resize(new_size,T());}
     void clear() {erase(begin(),end());}

 protected:
     //配置空间并填满内容
     iterator allocate_and_fill(size_type n,const T& x)
     {
         iterator result=data_allocator::allocate(n);
         uninitialized_fill_n(result,n,x);
         return result;
     }
};

 

1.定义和初始化vector对象

vector<T> v1;  　　　  //v1是一个空vector，执行默认初始化

vector<T> v2(v1) ;　　//v2中包含v1所有元素的副本

vector<T> v2 = v1;　　//跟上面等价

vector<T> v3(n, val) ;　//v3包含了n个val元素

vector<T> v4(n);　　　//v4中包含n个重复执行了值初始化的对象，值初始化，int型为0，string型为空字符

vector<T> v5{a,b,c...};　//v5中包含了初始值个数的元素，列表初始化 。vector<T> v5(a,b,c..);错误

vector<T> v5 = {a,b,c...}; //同上

vector<int> tmp(vec.begin(), vec.begin() + 3);    //用向量vec的第0个到第2个值初始化tmp

例：

vector<int> v1(10);　　//v1有10个元素都为0

vector<int> v2{10};　　//v2有一个元素，为10

vector<int> v3(10,1);　　//v3有10个元素，都为1

vector<int> v4{10, 1};　　//v4有两个元素，为10，1

2.vector的元素操作

(1). 容量

• 向量大小： vec.size();
• 向量最大容量： vec.max_size();
• 更改向量大小： vec.resize();
• 向量真实大小： vec.capacity();
• 向量判空： vec.empty(); //相比vec.size()==0用vec,empty()判断更好
• 减少向量大小到满足元素所占存储空间的大小： vec.shrink_to_fit(); 

(2). 修改

• 多个元素赋值： vec.assign(); //类似于初始化时用数组进行赋值，其旧元素会被替换
• 末尾添加元素： vec.push_back();
• 末尾删除元素： vec.pop_back();
• 在pos位置插入一个elem元素的拷贝，返回新数据的位置:vec.insert(pos,elem);
• 在pos位置插入n个elem数据，无返回值:vec.insert(pos,n,elem);
• 在pos位置插入[beg,end)区间的数据，无返回值:vec.insert(pos,beg,end);
• 删除指定位置元素： vec.erase(const_iterator position);    vec.erase(const_iterator first, const_iterator last);删除指定区间元素
• 交换两个向量的元素： vec.swap();
• 清空向量元素： vec.clear();

(3)迭代器

• 开始指针：vec.begin();
• 末尾指针：vec.end(); //指向最后一个元素的下一个位置
• 指向常量的开始指针： vec.cbegin(); //意思就是不能通过这个指针来修改所指的内容，但还是可以通过其他方式修改的，而且指针也是可以移动的。
• 指向常量的末尾指针： vec.cend();
• 指向向量倒数第一个的指针： vec.rbegin();
• 指向向量倒数最后一个的指针：vec.rend();

(4)元素的访问

• 下标访问： vec[1]; //并不会检查是否越界
• at方法访问： vec.at(1); //以上两者的区别就是at会检查是否越界，是则抛出out of range异常
• 访问第一个元素： vec.front();
• 访问最后一个元素： vec.back();
• 返回一个指针： int* p = vec.data(); //可行的原因在于vector在内存中就是一个连续存储的数组，所以可以返回一个指针指向这个数组。这是是C++11的特性。

 例：

assign()

// vector assign
#include <iostream>
#include <vector>

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

  first.assign (7,100);             // 7 ints with a value of 100

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

  second.assign (it,first.end()-1); // the 5 central values of first

  int myints[] = {1776,7,4};
  third.assign (myints,myints+3);   // assigning from array.

  std::cout << "Size of first: " << int (first.size()) << '\n';
  std::cout << "Size of second: " << int (second.size()) << '\n';
  std::cout << "Size of third: " << int (third.size()) << '\n';
  return 0;
}

/*ouput
Size of first: 7 
Size of second: 5 
Size of third: 3
*/

capacity()

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

int main() {
     vector<int> myvector;
     for (int i = 0; i < 10; i++)
         myvector.push_back(i);
     cout << "size=" << (int)myvector.size() << endl;
     cout << "capacity=" << (int)myvector.capacity() << endl;
     cout << "max_size=" << (int)myvector.max_size() << endl;
     return 0;
}

 

 

iterator 

// vector::begin/end
#include <iostream>
#include <vector>

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

输出：myvector contains: 1 2 3 4 5

const_iterator

// vector::cbegin/cend
#include <iostream>
#include <vector>

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

  std::cout << "myvector contains:";
/*

for (vector<int> ::const_iterator iter = myvector.cbegin(); iter != myvector.cend(); ++iter)
*/

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

  return 0;
}

输出：myvector contains: 10 20 30 40 50

reverse_iterator

// vector::rbegin/rend
#include <iostream>
#include <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 

输出：myvector contains: 5 4 3 2 1

const_reverse_iterator 

// vector::crbegin/crend
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector = {1,2,3,4,5};

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

  return 0;
}

输出：myvector backwards: 5 4 3 2 1

const迭代器和const_iterator的区别

前者类似指针常量，指向的地址不可变，但元素内容可变，后者正好相反。

 vector<int> vv(10,9);  
 const vector<int> :: iterator iter = vv.begin();  

   ++iter;//报错

　 *iter = 10；//正确

vector<int> vv(10,9);  
vector<int> ::const_iterator iter ;  
for(iter = vv.begin(); iter != vv.end(); ++iter){  
　　    cout << *iter << endl;  
}  //这是正确的，iter本身的值是可以改变的
/*
for(iter = vv.begin(); iter != vv.end(); ++ iter){  
   *iter = 0;  
}//这是错误的
*/

data

// vector::data
#include <iostream>
#include <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;
}

输出：myvector contains: 10 20 0 100 0

emplace

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

void note(int a, int b, long int c) {
    cout << "size=" << a << endl;
    cout << "capacity=" << b << endl;
    cout << "max_size=" << c << endl;
}
int main() {
    vector<int> myvector{10,20,30};
    cout << "origin:";
    for (auto& i: myvector) cout << ' ' << i;
    cout << endl;
    
    note(myvector.size(), myvector.capacity(), myvector.max_size());
    
    myvector.emplace(myvector.begin()+2, 1);
    cout << "----first modify----" << endl;
    for(auto& i: myvector) 
        cout << ' ' << i;
    cout << endl;
    
    note(myvector.size(), myvector.capacity(), myvector.max_size());
    
    auto it = myvector.emplace(myvector.begin()+1, 100);
    myvector.emplace(it, 666);
    cout << "---second modify---" << endl;
    for (; it < myvector.end()-1; it++) 
        cout << ' ' << *it;
    cout << endl;
    
    note(myvector.size(), myvector.capacity(), myvector.max_size());
    
    myvector.emplace(it, 200);
    cout << "---third modify---" << endl;
    for (auto& j: myvector) 
        cout << " " << j;
    cout << "\n";
    note(myvector.size(), myvector.capacity(), myvector.max_size());
    cout << "-----last-----" << endl;
    myvector.emplace(myvector.end(), 300);
    for (auto& x: myvector){
        cout << ' ' << x;
    }
    cout << endl;
    note(myvector.size(),myvector.capacity(), myvector.max_size());
    return 0;
}

 

 

 

 

//vector<int>::iterator it = myvector.emplace(myvector.emplace.end(), 1);

 

 

 

 

emplace_back

// vector::emplace_back
#include <iostream>
#include <vector>

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

输出：myvector contains: 10 20 30 100 200

erase

// erasing from vector
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector;

  // set some values (from 1 to 10)
  for (int i=1; i<=10; i++) myvector.push_back(i);

  // erase the 6th element
  myvector.erase (myvector.begin()+5);

  // erase the first 3 elements:
  myvector.erase (myvector.begin(),myvector.begin()+3);

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

  return 0;
}
Edit & Run

输出：myvector contains: 4 5 7 8 9 10