vector是連續儲存結構，支援隨機的高效的隨機和在尾部進行插入、刪除操作，其它位置的插入、刪除操作相對來說效率較低。

vector相當於一個數組，但它的陣列空間大小需要寫一程式來實現。

它的記憶體分配原理大概可分為下面幾步：

1）首先分配一塊記憶體空間進行儲存；
2）當所需儲存的資料超過分配的空間時，再重新分配一塊空間；
3）將舊元素複製到新空間；
4）釋放舊空間。

實現程式碼如下：

vector.h

#pragma once

#include<stdio.h>
#include<assert.h>
#include<string.h>
#include<iostream>
using namespace std;

typedef int DataType;

class Vector
{
public:
  Vector()
    :_first(NULL),_finish(NULL),_endofstorage(NULL)
  {}

  Vector(const Vector& v){
    if (v.Size() > 0){
      _first = new DataType(v.Size());
      memcpy(_first,v._first,sizeof (DataType)*v.Size());
    }
    if (_first > 0){
      _finish = _first + v.Size();
      _endofstorage = _first + v.Size();
    }
    _first = _finish = _endofstorage = NULL;
  }

  Vector& operator=(const Vector& v){
    if (this != &v){
      /*swap(_first,v._first);
      swap(_finish,v._finish);
      swap(_endofstorage,v._endofstorage);*/

      DataType* tmp = new DataType(v.Size());
      memcpy(tmp,_first,sizeof(DataType)*v.Size());
      delete _first;
      _first = tmp;
      _finish = _first + v.Size();
      _endofstorage = _first + v.Size();
    }
    return *this;
  }

  ~Vector(){
    delete[] _first;
    _first = _finish = _endofstorage = NULL;
  }

  void Print(){
    DataType* cur = _first;
    while (cur != _first){
      cout << "*cur" << endl;
      cur++;
    }
    cout << endl;
  }

  size_t Size() const{
    return _finish - _first;
  }

  size_t Capacity() const{
    return _endofstorage - _first;
  }

  void Expand(size_t n){
    if (n > Capacity()){
      DataType* tmp = new DataType(n);
      size_t size = Size();
      memcpy(tmp,sizeof(DataType)*size);
      delete[] _first;
      _first = tmp;
      _finish = _first + size;
      _endofstorage = _first + n;
    }
  }

  void PushBack(DataType x){
    if (_finish == _endofstorage){
      size_t capacity = Capacity() > 0 ? Capacity() * 2 : 3;
      Expand(capacity);
      /*if (Capacity() == 0){
        Expand(3);
      }
      else{
        Expand(Capacity() * 2);
      }*/
    }
    *_finish = x;
    ++_finish;
  }

  void PopBack(){
    assert(_finish > _first);
    --_finish;
  }

  void Reserve(size_t n){
    if (n > Capacity()){
      Expand(n);
    }
  }

  void Insert(size_t pos,DataType x){
    assert(pos < Size());
    if (_finish = _endofstorage){
      size_t capacity = Capacity() > 0 ? Capacity() * 2 : 3;
      Expand(capacity);
    }
    int tmp = Size() - 1;
    while (tmp >= (int)pos){
      _first[tmp + 1] = _first[tmp];
      --tmp;
    }
    _first[pos] = x;
    ++_finish;
  }

  void Erase(size_t pos){
    assert(pos < Size());
    size_t cur = pos;
    while (cur < Size()-1){
      _first[cur] = _first[cur] + 1;
      ++cur; 
    }
    --_finish;
  }

  size_t Find(DataType x){
    DataType *cur = _first;
    while (cur != _finish){
      if (*cur == x){
        return cur - _first;
      }
      ++cur;
    }
    return -1;
  }
private:
  DataType* _first;
  DataType* _finish;
  DataType* _endofstorage;
};

test.cpp

#include"vector.h"

void Tset(){
  Vector v;
  v.PushBack(1);
  v.PushBack(2);
  v.PushBack(3);
  v.PushBack(4);
  v.PopBack();
  v.Print();

  size_t pos = v.Find(1);
  printf("pos->data:expcet 1,axtual %lu",pos);

  Vector v1;
  v1.Insert(1,0);
  v1.Print();

  Vector v2;
  v2.Erase(3);
  v2.Print();
}

int main(){
  Tset();
  return 0;
}

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。