vector模拟实现
#include<vector>
#include<iostream>
#include<array>
using namespace std;
namespace my_vector
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
public:
vector() :_start(nullptr), _finish(nullptr), _endOfStorage(nullptr){}
vector(initializer_list<T> il):_start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
{
reserve(il.size());
for (auto &e : il)
{
push_back(e);
}
}
vector(vector<T> &v) :_start(nullptr), _finish(nullptr), _endOfStorage(nullptr)
{
reserve(v.capacity());
Swap(v);
}
vector(int n, const T &value = T())
{
reserve(n);
while (n--)
{
push_back(value);
}
}
vector& operator=(const T &v)
{
reserve(v.capacity());
if (this != &v)
{
delete[] _start;
_start = new T[v.capacity()];
Swap(v);
}
return *this;
}
template<class Inputiterator>
vector(Inputiterator first, Inputiterator last)
{
reserve(last - first);
while (first != last)
{
push_back(*first);
++first;
}
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endOfStorage;
}
}
public:
void reserve(size_t n)
{
if (n > capacity())
{
size_t old_sz = size();
T* new_start = new T[n];
if (_start)
{
for (size_t i = 0; i < old_sz; ++i)
{
new_start[i] = _start[i];
}
}
delete[] _start;
_start = new_start;
_finish = new_start + old_sz;
_endOfStorage = _start + n;
}
}
void resize(size_t n, const T &x = T())
{
if (n == size())
return;
if (n < size())
{
_finish = _start + n;
return;
}
if (n>capacity())
reserve(n);
iterator it = _finish;
_finish = _start + n;
while (it != _finish)
{
*it = x;
++it;
}
}
public:
iterator insert(iterator pos, const T& x)
{
if (size() >= capacity())
{
size_t offset = pos - _start;
size_t new_capacity = (capacity() == 0) ? 1 : capacity() * 2;
reserve(new_capacity);
pos = _start + offset;
}
iterator end = _finish;
while (end > pos)
{
*end = *(end - 1);
end--;
}
*pos = x;
_finish++;
return pos;
}
iterator erase(iterator pos)
{
iterator p = pos;
while (p < _finish - 1)
{
*p = *(p + 1);
p++;
}
_finish--;
return pos;
}
void pop_back()
{
erase(end());
}
void push_back(const T &x)
{
insert(end(), x);
}
public:
void Swap(vector<T> &v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endOfStorage, v._endOfStorage);
}
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
public:
size_t capacity()
{
return _endOfStorage - _start;
}
size_t size()
{
return _finish - _start;
}
bool empty()const
{
return _start == _finish;
}
T& operator[](size_t pos)
{
assert(pos >= 0 && pos < size());
return _start[pos];
}
private:
iterator _start;
iterator _finish;
iterator _endOfStorage;
};
}
<测试>
void main()
{
my_vector::vector<int> v1 = { 1, 2, 3, 4, 5, 6 };
cout << "capacity = " << v1.capacity() << endl;
cout << "size = " << v1.size() << endl;
for (const auto &e : v1)
{
cout << e << " ";
}
cout << endl;
}