【STL】シミュレーション実装vector

本稿では,初歩的な実装であるため,C++シミュレーションでvectorを実装するいくつかのステップを初歩的に用いるが,STLライブラリのソースコードとはまだ異なり,後でSTLのvectorのような3つの反復器を用いてvectorを再シミュレーションする.

void PushBack(const DataType& data);
void PopBack();
void Insert(size_t pos, const DataType& data);
void Erase(size_t pos);
int Find(const DataType& data)const;
void Clear();
size_t Size()const;
void ReSize(size_t size, const DataType& data = DataType());
size_t Capacity()const;
bool Empty()const;
DataType& Front();
const DataType& Front()const;
DataType& Back();
const DataType& Back()const;
void Assign(size_t n, const DataType& data = DataType());
DataType& operator[](size_t index);
const DataType& operator[](size_t index)const;
DataType& At(size_t index);
const DataType& At(size_t index)const;

次に、シミュレーション実装STLのvectorコードを示す.

#include 
#include 
using namespace std;

typedef int DataType;
class Vector
{
public:
	//    
	explicit Vector(size_t capacity = 0)
		:_pData(NULL),
		_capacity(capacity),
		_size(0)
	{
		_pData = new DataType[_capacity];
	}

	//  size   data   
	//      
	Vector(const DataType& data)
		:_size(0)
		, _capacity(0)
		, _pData(NULL)
	{
		*this = data;
	}
	//       
	Vector& operator=(const Vector& v)
	{
		if (&v != this)
		{
			DataType* tmp = v._pData;
			_size = v._size;
			_capacity = v._capacity;
			for (size_t i = 0; i < v._size; ++i)
				{
				    _pData[i] = v._pData[i];
				}
			delete[] tmp;
		}
		return *this;
	}
	//    
	~Vector()
	{
		if (_pData)
		{
			delete[] _pData;
			_pData = NULL;
		}
	}

	/////////////////////////////////////
	void PushBack(const DataType& data);
	void PopBack();
	void Insert(size_t pos, const DataType& data);
	void Erase(size_t pos);
	int Find(const DataType& data)const;
	void Clear();
	size_t Size()const;
	void ReSize(size_t size, const DataType& data = DataType());
	size_t Capacity()const;
	bool Empty()const;
	DataType& Front();
	const DataType& Front()const;
	DataType& Back();
	const DataType& Back()const;
	void Assign(size_t n, const DataType& data = DataType());
	DataType& operator[](size_t index);
	const DataType& operator[](size_t index)const;
	DataType& At(size_t index);
	const DataType& At(size_t index)const;

	//////////////////////////////////////////////
private:
	void _CheckCapacity();
	friend std::ostream& operator<_size == NULL)
	{
		cout << "     ，    " << endl;
	}
	this->_size--;
}
//pos         
void Vector::Insert(size_t pos, const DataType& data)
{
	_CheckCapacity();
	DataType *tmp = new DataType[_size++];
	tmp = _pData;
	for (size_t i = _size; i >= pos; i--)
	{
		tmp[i] = tmp[i-1];
	}
	tmp[pos] = data;
}
//  pos      
void Vector::Erase(size_t pos)
{
	if (NULL == _pData[pos])
	{
		cout << "     ，    " << endl;
	}
	else
	{
		for (size_t i = _size; i >= pos; i--)
		{
			_pData[i-1] = _pData[i];
		}
		this->_capacity--;
		this->_size--;
	}
}
//    data   
int Vector::Find(const DataType& data)const
{
	for (size_t i = 0; i <= _size; i++)
	{
		if (_pData[i] == data)
		{
			return i;
		}
		return -1;
	}
}
//         
void Vector::Clear()
{
	*this = NULL;
	this->_capacity = 0;
	this->_size = 0;
}
//       
size_t Vector::Size()const
{
	return _capacity;
}
//  vector      
//  size    vector    ，
//vector               ，  size.        size        
//  size    vector    ，
//vector            ，
void Vector::ReSize(size_t size, const DataType& data = DataType())
{
	if (size < this->_size)
	{
		this->_size = size;
		for (size_t i = size; i < _size; i++)
		{
			_pData[i] = 0;
		}
	}
	else if (size == this->_size)
	{
	}
	else
	{
		this->_size = size;
	}
}
//  vector            
size_t Vector::Capacity()const
{
	return _capacity;
}
//      ，   true，    false
bool Vector::Empty()const
{
	if (NULL == _pData)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//    Vector          
DataType& Vector::Front()
{
	return *_pData;
}
const DataType& Vector::Front()const
{
	return *_pData;
}
DataType& Vector::Back()
{
	--_size;
}
const DataType& Vector::Back()const
{
	return _pData[_size - 1];
}
//   【first,last】         Vector   ，   N   X    vector   ，
//        vector        。
void Vector::Assign(size_t n, const DataType& data = DataType())
{
	DataType *tmp = new DataType[n];
	for (size_t i = 0; i <= n; i++)
	{
		tmp[i] = data;
	}
	if (n < _size)
	{
		_CheckCapacity();
	}
	_size = n;
	_pData = tmp;
	delete[] tmp;
}
//            
DataType& Vector::operator[](size_t index)
{
	return _pData[index];
}
//           
const DataType& Vector::operator[](size_t index)const
{
	return _pData[index];
}
DataType& Vector::At(size_t index)
{
	return _pData[index];
}
const DataType& Vector::At(size_t index)const
{
	return _pData[index];
}