前言
面试中可能会考你，怎么去实现一个vector呢？这需要了解vector的底层实现。
在这之前，需要学习动态内存管理，特别是allocator，在c++ primer一书中有讲解。
要实现的基础内容
在cplusplus网站上，查看常见用法如下：
成员函数
(构造器)
Construct vector (public member function )
(析构函数)
Vector destructor (public member function )
迭代器:
begin
Return iterator to beginning (public member function )
end
Return iterator to end (public member function )
容量:
size
Return size (public member function )
元素访问:
operator[]
Access element (public member function )
at
Access element (public member function )
修改器:
push_back
Add element at the end (public member function )
pop_back
Delete last element (public member function )
基础的vector的主要结构
#include <cstddef>
#include <stdexcept>
#include <memory>
#include <iterator>
template <typename T>
class vector
{
public:
using value_type = T;
using iterator = value_type *;
using size_type = std::size_t;
public:
vector() = default;
~vector();
iterator begin() const;
iterator end() const;
size_type size() const;
value_type &operator[](size_type i) const;
value_type &at(size_type i) const;
void push_back(const value_type &new_elem);
void pop_back();
private:
iterator startptr = nullptr;
iterator endptr = nullptr;
iterator capptr = nullptr;
std::allocator<value_type> alloc;
private:
void check_cap();
void free();
};
在我们这个类中，简单的实现了迭代器，push_back，pop_back，以及[]，at函数，size函数。为了实现内存管理还需要实现构造、析构函数，以及检查容量函数。
基础功能的内部实现
template <typename T>
typename vector<T>::iterator vector<T>::begin() const
{
return startptr;
}
template <typename T>
typename vector<T>::iterator vector<T>::end() const
{
return endptr;
}
template <typename T>
typename vector<T>::size_type vector<T>::size() const
{
return endptr - startptr;
}
template <typename T>
typename vector<T>::value_type &vector<T>::operator[](size_type i) const
{
return *(startptr + i);
}
template <typename T>
typename vector<T>::value_type &vector<T>::at(size_type i) const
{
if (startptr + i >= endptr)
{
throw std::runtime_error("out of range!");
}
return *(startptr + i);
}
template <typename T>
vector<T>::~vector()
{
free();
}
上面是简单函数的实现。仅仅是取出内部的数据而已。
template <typename T>
void vector<T>::free()
{
if (startptr)
{
for (auto p = startptr; p != endptr; p++)
{
alloc.destroy(p);
}
alloc.deallocate(startptr, endptr - startptr);
}
}
template <typename T>
void vector<T>::check_cap()
{
if (endptr == capptr)
{
int newsize = size() ? size() << 1 : 1;
auto newstartptr = alloc.allocate(newsize);
auto newendptr = uninitialized_copy(std::make_move_iterator(startptr), std::make_move_iterator(endptr), newstartptr);
free();
startptr = newstartptr;
endptr = newendptr;
capptr = newstartptr + newsize;
}
}
template <typename T>
void vector<T>::push_back(const value_type &new_elem)
{
check_cap();
alloc.construct(endptr, new_elem);
endptr++;
}
template <typename T>
void vector<T>::pop_back()
{
if(endptr-startptr>0){
alloc.destroy(endptr);
endptr--;
}
}
这部分是涉及到内存的部分，使用了allocator来管理内存。构造器将分配空间和构造函数分开，分为分配空间、回收空间、析构过程、构造过程，检查容量这部分涉及到这四个情况，首先分配新空间，然后在新位置上构造新元素，然后析构旧元素，释放旧空间。析构旧元素、释放旧空间使用free函数来完成。这里使用uninitialized_copy函数和make_move_iterator，移动迭代器以及无初始化拷贝函数来实现在新的位置上构造新的元素，以求加速新元素构造的速度。
高级函数与实现
erase
接下来完成一些额外的函数的实现，我们先从erase开始吧
erase删除从指定位置到指定位置的所有内容。函数原型为如下：
public:
iterator erase(const_iterator position);
iterator erase(const_iterator first, const_iterator last);
第一个函数也可以看做是第二个函数的调用而已。我们实现第二个函数如下：
template <typename T>
typename vector<T>::iterator vector<T>::erase(const_iterator first, const_iterator last)
{
if(last >= endptr || first < startptr) throw std::runtime_error("out of range!");
iterator newendptr = std::copy(last, static_cast<const_iterator>(endptr), first);
while(newendptr < endptr){
alloc.destroy(--endptr);
}
return endptr;
}
首先进行合法性检测。然后，使用std::copy将后面的内容部分复制到被删除的部分。注意copy被覆盖的部分会自动调用赋值函数，赋值函数内应该会调用析构函数。然后，如果还有需要析构的内容（这种情况发生在所移动的内容没有删除的内容长时才会发生），析构这些内容。之后返回end指针。
另外一个重载函数实现比较简单：
template<typename T>
typename vector<T>::iterator vector<T>::erase(const_iterator position)
{
return erase(position, position+1);
}
