miniVector模仿向量容器

#include <algorithm>
#include<iostream>
template<class T>
class miniVector
{
public:
	miniVector(int size=0);
	miniVector(const miniVector<T> &obj);
	~miniVector();
	miniVector& operator = (const miniVector<T> &rhs);
	T& back();
	const T& back() const;
	T& operator[] (int i);
	const T& operator[] (int i) const;
	void push_back(const T& item);
	void pop_back();
	int size() const;
	bool empty() const;
	int capacity() const;
	void insert(int i,const T& item);
	void erase(int i);
	void insertOrder(const T& item);
	void removeDuplicates();
private:
	int vCapacity;
	int vSize;
	T *vArr;
	void reserve(int n,bool copy);
};
template<class T>
void miniVector<T>::reserve(int n,bool copy)
{
	T *newArr;
	int i;
	newArr=new T[n];
	if(newArr==NULL)
		exit(1);
	if(copy)
		for(i=0;i<vSize;i++)
			newArr[i]=vArr[i];
	if(vArr!=NULL)
		delete [] vArr;
	vCapacity=n;
	vArr=newArr;
}
template<class T>
miniVector<T>::miniVector(const miniVector<T> &obj)
{
	vCapacity=obj.vCapacity;
	vSize=obj.vSize;
	vArr=new T[vCapacity];
	for(int i=0;i<obj.vSize;i++)
		vArr[i]=obj.vArr[i];
}
template<class T>
miniVector<T>::miniVector(int size):vSize(0),vCapacity(0),vArr(NULL)
{
	int i;
	if(size==0)
		return;
	reserve(size,false);
	vSize=size;
	for(i=0;i<vSize;i++)
		vArr[i]=T();
}
template<class T>
miniVector<T>::~miniVector()
{
	if(vArr!=NULL)
		delete [] vArr;
}
template<class T>
miniVector<T>& miniVector<T>::operator=(const miniVector<T> &rhs)
{
	int i;
	if(vCapacity<rhs.vSize)
		reserve(rhs.vSize,false);
	vSize=rhs.vSize;
	for(i=0;i<vSize;i++)
		vArr[i]=rhs.vArr[i];
	return *this;
}
template<class T>
void miniVector<T>::push_back(const T& item)
{
	if(vSize==vCapacity)
	{
		if(vCapacity==0)
			reserve(1,false);
		else
			reserve(2*vCapacity,true);
	}
	vArr[vSize]=item;
	vSize++;
}
template<class T>
void miniVector<T>::pop_back()
{
	if(vSize==0)
		exit(1);
	vSize--;
}
template<class T>
T& miniVector<T>::back()
{
	if(vSize==0)
		exit(1);
	return vArr[vSize-1];
}
template<class T>
const T& miniVector<T>::back() const
{
	if(vSize==0)
		exit(1);
	return vArr[vSize-1];
}
template<class T>
T& miniVector<T>::operator[](int i)
{
	if(i<0||i>vSize)
		exit(1);
	return vArr[i];
}
template<class T>
const T& miniVector<T>::operator[](int i) const
{
	if(i<0||i>vSize)
		exit(1);
	return vArr[i];
}
template<class T>
int miniVector<T>::size()const
{
	return vSize;
}
template<class T>
bool miniVector<T>::empty()const
{
	return vSize==0?true:false;
}
template<class T>
int miniVector<T>::capacity()const
{
	return vCapacity;
}
template<class T>
void miniVector<T>::insert(int i,const T &item)
{
	if(i>=vSize)
		exit(1);
	if(vSize+1>=vCapacity)
		reserve(2*vCapacity,true);
	for(int j=vSize-1;j>i;j--)//后移元素
		vArr[j+1]=vArr[j];
	vArr[i]=item;
	vSize++;
}
template<class T>
void miniVector<T>::erase(int i)
{
	if(i>vSize)
		exit(1);
	for(int j=i;j<vSize;j++)//前移
		vArr[j]=vArr[j+1];
	vSize--;
}
template<class T>
void miniVector<T>::insertOrder(const T& item)
{
	push_back(item);
	sort(vArr,vArr+vSize);
}
template<class T>
void miniVector<T>::removeDuplicates()
{
	if(vSize<2)
		return;
	sort(vArr,vArr+vSize);
	T *va,temp;
	va=new T[vCapacity];
	temp=va[0]=vArr[0];
	int si=0,i;
	for(i=1;i<vSize;i++)
	{
		if(temp!=vArr[i])
		{
			si++;
			temp=vArr[i];
			va[si]=vArr[i];
		}
	}
	vSize=si;
	for(int i=0;i<si;i++)
		vArr[i]=va[i];
	delete [] va;
}

 

 

主函数:

#include"miniVector.h"
#include<iostream>
#include<cstdlib>
#include<time.h>
using namespace std;
#define N 15
int main()
{
	miniVector<int > test;
	srand(time(NULL));
	for(int i=0;i<N;i++)
		test.push_back(rand()%20);
	test.insert(5,6);
	test.insertOrder(50);
	test.back()=12;
	for(int i=0;i<N+2;i++)
		cout<<test[i]<<' ';
	cout<<endl;
	test.removeDuplicates();
	for(int i=0;i<N+2;i++)
		cout<<test[i]<<' ';
	return 0;
}