C++STL -- vector实现

STL的vector简化实现

本质

vector说到底就是一个动态数组，我们需要做的就是管理动态数组的内存，和元素的增加，删除，移动等。

template <typename T>
class vector {
public:
    typedef T* iterator;
    typedef T& reference;
protected:
    iterator start;          //第一个元素
    iterator finish;         //最后一个元素的后面一位
    iterator end_of_storage; //capacity的位置
public:
    ...
};

构造函数

实现很简单，就是创建一个动态数组，然后将iterator赋值好就行。

public:
  vector() : start(0), finish(0), end_of_storage(0) {};
  vector(unsigned n, const T& value) { init(n, value); }
  explicit vector(unsigned n) { init(n, T()); }

这里我使用了辅助初始化的函数init（其他函数也要用），其实现如下：

private:
void init(unsigned n, const T& value) {
    assert(n > 0);
    start = new T[n];
    finish = start + n;
    end_of_storage = finish;
    for(int i = 0; i < n; i++) {
        start[i] = value;
    }
}

析构函数

主要就是进行内存释放，指针赋空值。

~vector() { destory(); }

这里用到了辅助函数（其他函数也要用），实现如下：

private:
void destory() {
  delete[] start;
  start = finish = end_of_storage = nullptr;
}

assign

先判断当前容量是否足够，不足则先分配两倍的容量，然后再赋值。

void assign(unsigned num, const T& value) {
  while(num > capacity()) {
    extendDouble();
  }
  for(int i = 0; i < num; i++) {
    start[i] = value;
  }
}
void assign(iterator first, iterator last) {
  unsigned num = (unsigned)(last - first);
  while(num > capacity()) {
    extendDouble();
  }
  for(int i = 0; i < num; i++) {
    start[i] = first[i];
  }
}

这里用到辅助函数extendDouble来分配两倍的容量，实现如下：

void extendDouble() {
  //确定两倍容量的值
  unsigned newCapacity = capacity() * 2;
  if(newCapacity == 0) newCapacity = 1;
  //将旧值放到新数组中
  T* newMen = new T[newCapacity];
  unsigned oldSize = size();
  for(int i = 0; i < oldSize; i++) {
    newMen[i] = start[i];
  }
  //施放旧数组，赋值为新数组
  destory();
  start = newMen;
  finish = start + oldSize;
  end_of_storage = start + newCapacity;
}

back

reference back() { return start[size()-1]; }

begin

iterator begin() { return start; }

capacity

unsigned capacity() const {
    return (unsigned)(end_of_storage - start);
}

clear

void clear() { finish = start; }

empty

bool empty() const { return size() == 0; }

end

iterator end() { return finish; }

erase

对于删除操作，主要就是要将被删除元素后面的元素向前移动。

iterator erase(iterator pos) {
    assert(pos < finish);
    //将之后的元素向前移动
    unsigned delta = (unsigned)(pos - start);
    for(int i = delta; i < size()-1; i++)
        start[i] = start[i+1];
    finish--;
    return pos;
}
iterator erase(iterator first, iterator last) {
    assert(last > first && last < finish);

    unsigned firstIndex = (unsigned)(first - start);
    unsigned lastIndex = (unsigned)(last - start);
    for(int i = firstIndex, m = lastIndex; m < size(); i++, m++)
        start[i] = start[m];
    finish -= (unsigned)(last - first);
    return first;
}

从这里可以看出，被删除元素后面的iterator都失效，而前面的iterator则依然有效。

front

reference front() { return start[0]; }

insert

insert实现复杂一点，需要先分配好足够的容量，然后将插入点后的元素全部移动n个单位，最后将n个值依次从插入点开始赋值。

void insert(iterator pos, unsigned n, const T& value) {
    unsigned posIndex = (unsigned)(pos - start);
    unsigned newSize = size() + n;
    //分配好需要的容量
    while(newSize > capacity())
        extendDouble();

    pos = start + posIndex;
    unsigned numNeedMove = (unsigned)(finish - pos);
    //将插入点后面的元素先放到一个临时数组存起来
    T* temp = new T[numNeedMove];
    for(int i = 0; i < numNeedMove; i++) {
        temp[i] = pos[i];
    }
    //将n个值依次从插入点开始赋值
    for(int i = 0; i < n; i++) {
        pos[i] = value;
    }
    //将插入点后的元素重新放回到数组中
    for(int i = n; i < n+numNeedMove; i++) {
        pos[i] = temp[i-n];
    }

    finish = start + newSize;
    delete temp;
    temp = nullptr;
}

void insert(iterator pos, const T& value) {
    insert(pos, 1, value);
}

void insert(iterator pos, iterator first, iterator last) {
    unsigned n = (unsigned)(last - first);
    unsigned posIndex = (unsigned)(pos - start);
    unsigned newSize = size() + n;
    while(newSize > capacity())
        extendDouble();

    pos = start + posIndex;
    unsigned numNeedMove = (unsigned)(finish - pos);
    T* temp = new T[numNeedMove];
    for(int i = 0; i < numNeedMove; i++) {
        temp[i] = pos[i];
    }

    for(int i = 0; i < n; i++) {
        pos[i] = first[i];
    }
    for(int i = n; i < n+numNeedMove; i++) {
        pos[i] = temp[i-n];
    }

    finish = start + newSize;
    delete temp;
    temp = nullptr;
}

pop_back

void pop_back() {
    if(empty()) return;
    finish--;
}

push_back

void push_back(const T& value) {
    //容量足够
    if(finish != end_of_storage) {
        start[size()] = value;
        finish++;
    }
    //容量不足
    else {
        unsigned oldSize = size();
        extendDouble();
        start[oldSize] = value;
    }
}

reserve

void reserve(unsigned n) {
        if(n <= capacity()) return;

        unsigned oldSize = size();
        T* newOne = new T[n];
        for(int i = 0; i < size(); i++) {
            newOne[i] = start[i];
        }

        destory();
        start = newOne;
        finish = start + oldSize;
        end_of_storage = start + n;
    }

resize

void resize(unsigned s, const T& value) {
    if(s < size())
        erase(begin() + s, end());
    else
        insert(end(), s - size(), value);
}
void resize(unsigned s) { resize(s, T()); }