简易版C++顺序表

String.h

#ifndef __VECTOR_H__
#define __VECTOR_H__

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

using namespace std;

typedef int DataType;

class Vector
{
public:
	Vector()       //构造函数
		:_array(0)
		,_size(0)
		,_capacity(0)
	{
		
	}
	Vector(DataType *array, size_t size)       //缺省构造函数
		:_array((DataType*)malloc(sizeof(DataType)*size))
		,_size(size)
		,_capacity(size)
	{
		
	}
	Vector(const Vector &v)       //拷贝构造
		:_array((DataType*)malloc(sizeof(DataType)*v._size))
		,_size(v._size)
		,_capacity(v._size)
	{
		memcpy(_array, v._array, sizeof(DataType)*v._size);
	}
	void Swap(Vector &v)        //交换
	{
		swap(_array, v._array);
		swap(_size, v._size);
		swap(_capacity, v._capacity);
	}

	Vector operator=(Vector &v)        //现代写法  赋值运算符重载
	{
		this->Swap(v);
		return *this;
	}

	~Vector()            //析构函数
	{
		free(_array);
		_size = _capacity = 0;
		_array = NULL;
	}

	void Print()        //输出函数
	{
		size_t i = 0;
		for (i = 0; i < _size; i++)
		{
			cout << _array[i] <<" ";
		}
		cout << endl;
	}

	void PushBack(const DataType &x)      //尾插
	{
		_CheckCapacity();
		_array[_size++] = x;
	}

	void PopBack()           //尾删
	{
		assert(_size > 0);
		--_size;
	}

	void PushFront(const DataType &x)          //头插
	{
		_CheckCapacity();
		size_t end = _size;
		_size += 1;
		while (end > 0)
		{
			_array[end] = _array[end - 1];
			end--;
		}
		_array[0] = x;
	}

	void PopFront()           //头删
	{
		assert(_size > 0);
		size_t begin = 0;
		while (begin < _size)
		{
			_array[begin] = _array[begin + 1];
			begin++;
		}
		_size -= 1;
	}

	int Find(const DataType &x)        //查找
	{
		size_t begin = 0;
		while (begin < _size)
		{
			if (_array[begin] == x)
			{
				return begin;
			}
			begin++;
		}
		return -1;
	}

	void Insert(size_t pos, const DataType &x)         //插入
	{
		assert(pos <= _size);
		_CheckCapacity();
		size_t end = _size;
		_size += 1;
		while (end > pos)
		{
			_array[end] = _array[end - 1];
			end--;
		}
		_array[pos] = x;
	}

	void Erase(size_t pos)      //删除
	{
		assert(pos < _size);
		size_t begin = pos;
		while (begin < _size)
		{
			_array[begin] = _array[begin + 1];
			begin++;
		}
		_size -= 1;
	}

	DataType& operator[](size_t pos) 
	{
		assert(pos < _size);
		return _array[pos];
	}

private:
	DataType* _array;         //数组指针
	size_t _size;             //有效数字个数
	size_t _capacity;         //容量
private:
	void _CheckCapacity()          //检查容量
	{
		if (_size >= _capacity)
		{
			size_t NewCapacity = _capacity * 2 + 3;
			_array = (DataType *)realloc(_array, NewCapacity * sizeof(NewCapacity));
			assert(_array);       //申请失败报错
			_capacity = NewCapacity;
		}
	}
};

#endif // !__SEQLIST_H__

对应的测试用例：

#include"Vector.h"

void Test()
{
	Vector v1;
	v1.PushBack(1);
	v1.PushBack(2);
	v1.PushBack(3);
	v1.PushBack(4);
	v1.Print();

	Vector v2(v1);
	v2.Print();
	v2[0] = 8;
	v1.Print();
	v2.Print();

	v1.PopBack();
	v1.PopBack();
	v1.PopBack();
	v1.PopBack();
	v1.Print();

	v1.PushFront(1);
	v1.PushFront(2);
	v1.PushFront(3);
	v1.PushFront(4);
	v1.Print();

	v1.Find(1);
	printf("%d\n", v1.Find(1));
	v1.Insert(v1.Find(1), 5);
	v1.Print();
	v1.Erase(v1.Find(5));
	v1.Print();
	v1.PopFront();
	v1.Print();
	v1.PopFront();
	v1.PopFront();
	v1.PopFront();
	v1.Print();

}

int main()
{
	Test();

	system("pause");
	return 0;
}