【C++】实现容器Vector

容器（Vector）

容器是这样的一种数据存储上的【对象类型】，该对象可以持有其他对象或者其他对象的指针。

Vector的一些接口

我们可以通过【C++Reference】来搜索一下容器



我们发现容器里有很多的接口

这次我们实现以下接口

template<typename T>

class Vector

{

public:

Vector();

Vector(const T arr[], size_t size);

Vector(const Vector& v);

Vector& operator=(const Vector& s);

~Vector();

public:

void PushBack(const T& data);

void PopBack();

void Insert(size_t pos, const T& data);

void Erase(size_t pos);

const T& operator[](size_t index)const;

T& operator[](size_t index);

T& Front();

const T& Front()const;

T& Back();

const T& Back()const;

bool Empty()const;

size_t Size()const;

size_t Capacity()const;

void Clear();

void Resize(size_t size);

private:

void _CheckCapacity();

private:

T* _pData;

size_t _capacity;

size_t _size;

};

Vector的实现

template<typename T>
class Vector
{
friend ostream& operator<<(ostream &_cout,const Vector<T> &t)
{
for (size_t idx = 0; idx < t._size; ++idx)
{
_cout << t._pData[idx]<<" ";
}
return _cout;
}
public:
Vector()
:_pData(new T[3])
, _capacity(3)
, _size(0)
{}

Vector(const T arr[], size_t size)
:_pData(new T[3])
, _size(0)
, _capacity(3)
{
for (size_t idx = 0; idx < size; ++idx)
{
CheckCapacity();
_pData[idx] = arr[idx];
++_size;
}
}

Vector(const Vector<T>& t)
:_pData(new T[sizeof(T)*(t._capacity)])
, _capacity(t._capacity)
, _size(t._size)
{
for (size_t idx = 0; idx < t._size; ++idx)
{
_pData[idx] = t._pData[idx];
}
}

Vector<T>& operator=(const Vector<T> &t)
{
if (this != &t)
{
T* Temp = new T[t._capacity];
for (size_t idx = 0; idx < t._size; ++idx)
{
Temp[idx] = t._pData[idx];
}
delete[] _pData;
_pData = Temp;
_size = t._size;
_capacity = t._capacity;
}
return *this;
}

~Vector()
{
if (NULL != _pData)
{
delete[] _pData;
}
_pData = NULL;
_size = 0;
_capacity = 0;
}

void PushBack(const T& data)
{
CheckCapacity();
_pData[_size] = data;
++_size;
}

void PopBack()
{
if (_size > 0)
{
--_size;
}
}

void Insert(size_t pos, const T& data)
{
if (pos > _size)
{
return;
}
CheckCapacity();
size_t idx = _size;
for (; idx > pos; --idx)
{
_pData[idx - 1] = _pData[idx];
}
_pData[idx] = data;
++_size;
}

void Erase(size_t pos)
{
if (pos > _size)
{
return;
}
for (size_t idx = 0; idx < _size; ++idx)
{
_pData[idx] = _pData[idx + 1];
}
--_size;
}

T& Front()
{
return _pData[0];
}

const T& Front()const
{
return _pData[0];
}

T& Back()
{
return _pData[_size - 1];
}

const T& Back()const
{
return _pData[_size - 1];
}

const T& operator[](size_t index)const
{
return _pData[index];
}

//ture 为空
//false 不为空
bool Empty()const
{
if (0 == _size)
{
return ture;
}
return false;
}

size_t Size()
{
return _size;
}

size_t Size()const
{
return _size;
}

size_t Capacity()
{
return _capacity;
}

size_t Capacity()const
{
return _capacity;
}

void Clear()
{
_size = 0;
}

void Resize(size_t size,T &data = 0)
{
if (size < _size)
{
_size = size;
}
for (size_t idx = _size; idx < size; ++idx)
{
_pData[idx] = data;
}
}
private:
T* _pData;
size_t _capacity;
size_t _size;
void CheckCapacity()
{
while (_size >= _capacity)
{
T* Temp = new T[2*_capacity];
for (size_t idx = 0; idx < _size; ++idx)
{
Temp[idx] = _pData[idx];
}
delete[] _pData;
_pData = Temp;
_capacity *= 2;
}
}
};