Vector.h
#pragma once
#include <iostream>
#include <string.h>
#include <assert.h>
template<class T>
class Vector{
public:
typedef T* iterator;
typedef const T* const_iterator;
Vector()
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{}
Vector(const Vector<T>& v)
: _start(nullptr)
, _finish(nullptr)
, _endofstorage(nullptr)
{
Reserve(v.Size());
for (size_t i = 0; i < v.Size(); ++i){
PushBack(v[i]);
}
}
Vector<T>& operator=(Vector<T> v){
swap(v);
return *this;
}
~Vector(){
if (_start){
delete[] _start;
_start = nullptr;
_finish = nullptr;
_endofstorage = nullptr;
}
}
public:
iterator begin(){
return _start;
}
iterator end(){
return _finish;
}
const_iterator begin() const{
return _start;
}
const_iterator end() const{
return _finish;
}
public:
void Reserve(size_t n, const T& val = T());
void Resize(size_t n, const T& val = T());
public:
void PushBack(const T& x);
void PopBack();
void Insert(iterator pos, const T& x);
void Erase(iterator pos);
public:
T& operator[](size_t pos){
assert(pos < Size());
return _start[pos];
}
const T& operator[](size_t pos) const{
assert(pos < Size());
return _start[pos];
}
public:
size_t Size() const{
return _finish - _start;
}
size_t Capacity() const{
return _endofstorage - _start;
}
void swap(Vector<T>& v){
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
private:
T* _start;
T* _finish;
T* _endofstorage;
};
Vector.cpp
#include "Vector.h"
template<class T>
void Vector<T>::Reserve(size_t n, const T& val = T()){
if (n > Capacity()){
size_t size = Size();
T* temp = new T[n];
if (_start){
for (size_t i = 0; i < size; ++i){
temp[i] = _start[i];
}
}
delete[] _start;
_start = temp;
_finish = _start + size;
_endofstorage = _start + n;
}
}
template<class T>
void Vector<T>::Resize(size_t n, const T& val = T()){
if (n <= Size()){
_finish = _start + n;
}
else{
Reserve(n);
while (_finish != _start + n){
*_finish = val;
++_finish;
}
}
}
template<class T>
void Vector<T>::PushBack(const T& x){
if (_finish == _endofstorage){
size_t capacity = Capacity() == 0 ? 4 : Capacity() * 2;
Reserve(capacity);
}
*_finish = x;
++_finish;
}
template<class T>
void Vector<T>::PopBack(){
if (_finish > _start){
--_finish;
}
}
template<class T>
void Vector<T>::Insert(iterator pos, const T& x){
assert(pos < _finish);
if (_finish == _endofstorage){
size_t offset = pos - _start;
size_t capacity = Capacity() == 0 ? 4 : Capacity() * 2;
Reserve(capacity);
pos = _start + offset;
}
iterator end = _finish - 1;
while (end >= pos){
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
}
template<class T>
void Vector<T>::Erase(iterator pos){
assert(pos < _finish);
iterator it = pos;
while (it < _finish - 1){
*it = *(it + 1);
++it;
}
--_finish;
return pos;
}