c++模拟实现vector

上一篇说到了list，这一篇我们来讨论讨论vector

vector和list都是STL中的常见容器。

它是一种顺序容器，支持随机访问。

和数极为相似，都是一块连续的内存空间。数组有的功能，它基本都能实现。

和数组不同的地方在于：数组分配到的空间是死的，不可变的；而vector却可以随着元素的不断插入，它自己会进行增容。当程序员无法知道到底需要多大的空间的时候，这无疑是最好的方法，并且可以最大程度上的节约空间。

下面直接上代码。

注释很清晰，希望对读者有帮助。

#include<iostream>
#include<assert.h>
#include<windows.h>

using namespace std;

typedef int DataType;
class Vector
{
public:
	Vector(size_t capacity = 3)
		:_data(new DataType[capacity])  //开辟空间
		, _size(0)
		, _capacity(capacity)
	{}


	//有n个值为data的元素
	Vector(const DataType& data, size_t n)
	{}


	//拷贝构造函数
	Vector(const Vector& v)
		//:_capacity(v._capacity)
		//_size(v._size)
	{
		_data = new DataType(_capacity);
		//比较1和2的优缺点
		//1.
		//memcpy(_data, v._data, sizeof(DataType)* _size);
		//2.
		for (size_t i = 0; i < _size; i++)
			_data[i] = v._data[i];
	}

	//复制运算符重载
	Vector& operator=(const Vector& v)
	{
		if (this != &v)
		{
			DataType* temp = new DataType[v._capacity];
			for (size_t i = 0; i < v._size; i++)
			{
				temp[i] = v._data[i];
			}
			delete _data;
			_data = temp;
			_capacity = v._capacity;
			_size = v._size;
		}
		return *this;
	}


	//析构函数
	~Vector()
	{
		if (_data != NULL)
		{
			delete _data;
			_data = NULL;
			_size = 0;
			_capacity = 0;
		}
	}



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

private:

	//检查容量是否已满
	void CheckCapacity()
	{
		//实际大小>容量，扩容
		if (_size >= _capacity)
		{
			DataType* temp = new DataType[_capacity * 2 + 3];
			for (int i = 0; i < _size; i++)
			{
				temp[i] = _data[i];
			}
			delete _data;
			_data = temp;
			//_capacity *= 2;
		}
	}



	DataType* _data;
	size_t _size;
	size_t _capacity;
};

下面是函数实现部分

#include"Vector.h"
 
void Vector::PrintVector()
{
	for (size_t i = 0; i < _size; i++)
		cout << _data[i];
	cout << endl;

}



void Vector::PushBack(const DataType& data)
{
	CheckCapacity();
	_data[_size++] = data;
}



bool Vector::Empty()
{
	return _size == 0;
}



void Vector::PopBack()
{
	if (!Empty())
		--_size;
}


//任意位置的插入
void Vector::Insert(size_t pos, const DataType& data)
{
	//检查pos是否合法
	assert(pos);
	//检查容量
	CheckCapacity();
	for (int i = pos; i < _size; i++)
	{
		//将前一个赋值给后一个
		_data[i] = _data[i-1];
	}
	_data[pos - 1] = data; //将data赋值给第pos个元素
	_size++;
}


//任意位置的删除
void Vector::Erase(size_t pos)
{
	assert(pos);
	if (!Empty())
	{
		//pos前的元素不需要变动，只需要将其后的元素集体往前挪一个，最后给size++
		for (int i = pos; i < _size; i++)
		{
			_data[i - 1] = _data[i];
		}
		_size--;
	}
}


void Vector::Find(const DataType& data)
{
	for (int i = 0; i < _size; i++)
	{
		if (_data[i] == data)
			cout << "找到了" << endl;
	}
}


//清空元素
void Vector::Clear()
{
	if (_data != NULL)
	{
		delete _data;
		_data = NULL;
		_capacity = 0;
		_size = 0;
	}
}


size_t Vector::Size()
{
	return _size;
}


size_t Vector::Capacity()
{
	return _capacity;
}


//改变Vector中_size的大小
void Vector::ReSize(size_t size, const DataType& data)
{
	//size<_size
	if (size < _size)
		_size = size;
	// size > _size
	else if (size>_size)
	{
		int _oldsize = _size;
		_size = size;
		while (1)
		{
			//_size < size < _capacity
			if (size < _capacity)
				break;
			else
				CheckCapacity();
		}
		//size > _capacity
		for (int i = _oldsize; i < _size; i++)
		{
			_data[i] = data;
		}
	}
}
void Vector::Front()
{
	 cout<<"the first is:"<< _data[0]<<endl;
}



void Vector::Back()
{
	cout << "the last is:" << _data[_size-1] << endl;
}

//DataType& operator[](size_t index)

DataType& Vector::At(size_t n)
{
	assert(n > 0 && n <= _size);
	return _data[n - 1];
}



void FunTest()
{
	Vector v;
	v.PushBack(1);
	v.PushBack(2);
	v.PushBack(3);
	v.PushBack(4);
	v.PushBack(5);
	v.PushBack(6);
	v.PrintVector();

	v.PopBack();
	v.PrintVector();

	//v.Insert(2,6);
	//v.PrintVector();
	//能插入，但是会破坏掉后面的数，并且会越界访问


	v.Erase(5);
	v.PrintVector();



	v.Find(2);

	v.Front();
	 
	v.Back();
}


int main()
{
	FunTest();
	system("pause");
	return 0;
}

接下来是测试结果：