# 1, Foreword

vector source code is too complex to look at. The essence and general framework and important functions are listed here and analyzed.

# 2, vecotr framework construction

Before implementing vector, you need to understand this figure. Similar to string, you will also record the size and capacity

In this array, there are three pointers pointing to the starting position start, the data ending position finish and the end of the space capacity_ of_ The storage location has spare space. If the added data exceeds the capacity, the capacity needs to be increased

## 1. vector introduction

1. vector Is a variable size array sequence container 2. Like arrays, they are spatially contiguous 3. Use dynamic allocation array to store elements; When increasing capacity, it does not reallocate the size every time, but allocates some additional space to accommodate possible growth(finish and endofstorage between). vector It takes up more storage space. In order to obtain the ability to manage storage space and grow dynamically in an effective way. 4. Compared with other dynamic sequence containers( deques, lists and forward_lists)， vector It is more efficient to access elements, and it is relatively efficient to add and delete elements at the end. For other delete and insert operations that are not at the end, the efficiency is lower lists and forward_lists Uniform iterators and references are better.

## 2. Framework

The following is the general framework of vector, which is very similar to the sequence table, and realizes addition, deletion, query and modification

namespace vectorSimu{ template<class T> class vector{ public: typedef T* iterator; iterator begin(); iterator end(); //Default member function vector(); vecotr(size_t n, const T& val); vector(const vector<T>& val); //copy construction //Size and rongliang size_t size(); size_t capacity(); //Capacity expansion void reserve(size_t n); void resize(size_t n, const T& val = T()); //Read container information T& operator[](size_t pos); //Modification and deletion void push_back(const T& val); void pop_back(); void insert(iterator pos, const T& val); iterator erase(iterator pos); void swap(vector<T>& v); //Deconstruction ~vector(); private: iterator _start; iterator _finish; iterator _endofstorage; }; }

## 3. Constructor

Construct a function without parameters and set its members to nullptr

vector() : _start(nullptr) , _finish(nullptr) , _endofstorage(nullptr) {}

With parameter construction, the call can support n such Vals of T type initially. First call reserve to judge whether n exceeds the current capacity. If it exceeds the current capacity, reallocate a group of N sizes of space

vector(size_t n, const T& val = T()) :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) { reserve(n); //Determine whether n exceeds capacity reserve(n); for(int i=0; i<n; ++i){ push_back(val); } }

We can also use interval iterators to construct and tail the data

//Class template to member function, and you can redefine template parameters template <class InputIterator> vector(InputIterator first, InputIterator last){ while(first != last){ push_back(*first); ++first; } }

## 4. Copy structure

Traditional writing method I:

vector(const vector<T>& v){ _start = new T[v.capacity()]; memcpy(_start, v._start, sizeof(T)*v.size()); _finish = _start + v.size(); _endofstorage = _start + v.capacity(); }

Traditional writing method 2:

vector(const vector<T>& v) : _start(nullptr) , _finish(nullptr) , _endofstorage(nullptr) { reserve(v.capacity()); for(const auto& e: v){ push_back(e); } }

The modern method of deep copy is different from the traditional one. The traditional way of writing is to open up a new set of space directly, and then store the original stored data in the new space. Modern writing is done by copying to temporary variables.

vector(const vector<T>& v) : _start(nullptr) , _finish(nullptr) , _endofstorage(nullptr) { vector<T> tmp(v.begin(), v.end()); this->swap(tmp); } void swap(vector<T>& v){ ::swap(_start, v._start); ::swap(_finish, v._finish); ::swap(_endofstorage, v._endofstorage); }

## 5. Assignment overload

In traditional writing, this method has the same effect as copy construction

vector<T>& operator=(const vector<T>& v){ if(this != &v){ delete [] _start; _start = _finish = _endofstorage = nullptr; reserve(v.capacity()); for(const auto& e:v){ push_back(e); } } return *this; }

In modern writing, the formal parameters are copied once, and then the this class is exchanged with the copied class

vector<T>& operator=(vector<T> v){ swap(v); return *this; }

## 6. Iterator function

In fact, the begin ning of the iterator encapsulates the first address of this type, and the end corresponds to the end of the type

typedef T* iterator; iterator begin(){ return _start; } iterator end(){ return _finish; }

## 7. size and capacity

This is also relatively simple. You can calculate the address

size_t size(){ return _finish - _start; } //Total capacity size size_t capacity(){ return _endofstorage - _start; }

## 8. Capacity expansion

When we push back the information to the vector, we need to judge whether we need to increase the capacity. If it is larger than the current container, we can open a new group of space and release the original space

void reserve(size_t n){ if(n>capacity()){ size_t sz = size(); T* tmp = new T[n]; if(_start){ //If the beginning is not empty for(size_t i=0; i<sz; ++i){ tmp[i] = _start[i]; } delete[] _start; //Release original container data } _start = tmp; _finish = _start + sz; _endofstorage = _start + n; } }

There are three situations to consider when reallocating size

In the first case, when the size of the reallocation is less than size, that is, the first address to N, the rest will be trimmed

In the second case, when N is greater than the current capacity, you need to reserve() new space again and initialize it to the given val value

In the third case, when N is less than the current capacity and larger than size, the remaining complement is the given val value

void resize(size_t n, const T& val = T()){ if(n < size()){ _finish = _start + n; }else{ if(n > capacity()){ reserve(n); } while(_finish < n + _start){ *_finish = val; ++_finish; } } }

## 9. pushback and popback

It should be noted here that the first push needs to determine whether the finish pointer is in the same position as the capacity pointer, so the capacity needs to be expanded

//Modification and deletion void push_back(const T& val){ if(_finish == _endofstorage){ size_t newcapacity = capacity()==0 ? 4 : capacity() * 2; reserve(newcapacity); } *_finish = val; _finish++; }

pop data is also relatively simple. Move the finish pointer forward directly

void pop_back() { assert(!empty()); --_finish; }

## 10. Insert and delete specified location data

Before inserting, you need to judge whether the pos is between start and finish, otherwise an error will be reported

Before inserting data, you need to judge whether the capacity is sufficient

When inserting data in the middle, the data behind the pos needs to move backward in turn. This algorithm is not efficient, so it is not recommended

iterator insert(iterator pos, const T& val){ assert(pos >= _start && pos<=_finish); if(_finish == _endofstorage){ size_t len = pos - _start; size_t newcapacity = capacity() == 0 ? 4: capacity()*2; reserve(newcapacity); pos = _start + len; } iterator end = _finish - 1; while(end >= pos){ *(end+1) = *end; --end; } *pos = val; ++_finish; return pos; }

Remove all data after pos

iterator erase(iterator pos){ assert(pos>=_start && pos < _finish); iterator it = pos + 1; while(it != _finish){ *(it-1) = *it; ++it; } --_finish; return pos; }

## 11. Access by subscript

//Read container information T& operator[](size_t pos){ assert(pos < size()); return _start[pos]; }

Test to verify

# 3, Complete code

Gitee link 🔗 🔗 🔗

👉 👉 👉 vector simulation 👈 👈 👈

It's not easy to create. If the article helps you, please like it for three times:)