STL中vector部分功能的实现

#ifndef __VECTOR_H__
#define __VECTOR_H__

template <class Object>
class Vector
{
public:
	explicit Vector(int size = 0);//加explicit关键字是为了防止类型的隐式转换
	Vector(const Vector &rhs);    //拷贝构造函数
	~Vector();

	const Vector & operator=(const Vector &rhs);//赋值函数
	void resize(int newSize);                   //修改大小
	void reserve(int newCapacity);              //修改容量

	Object & operator[](int index);             //重载下标操作符
	const Object & operator[](int index) const; //下标操作符重载的重载函数

	bool empty() const;                         //判空
	int size() const;                           //返回大小
	int capacity() const;                       //返回容量

	void push_back(const Object &x);            //在尾部插入元素
	void pop_back();                            //删除尾部元素
	const Object &back() const;                 //返回最后一个元素

	/* vector类型的迭代器和指针的相似性意味着使用vector而不使用C++
	 * 数组会导致稍高一点的资源消耗，其缺点是没有错误检测。如果迭代
	 * itr器冲出了末端标记的话，++itr或*itr都不需要标识错误。解决这
	 * 个问题需要使iterator和const_iterator是真正的嵌套类类型而不是
	 * 简单的指针变量。
	 */
	typedef Object* iterator;
	typedef const Object* const_iterator;

	iterator begin()
	{
		return &obj[0];
	}
	iterator end()
	{
		return &obj[m_Size];
	}
	const_iterator begin() const
	{
		return &obj[0];
	}
	const_iterator end() const
	{
		return &obj[m_Size];
	}

	enum{MIN_CAPACITY = 16};//设置一个枚举来表示最小容量
private:
	int m_Size;
	int m_Capacity;
	Object *obj;
};

template <class Object>
Vector<Object>::Vector(int size = 0)
{
	m_Size = size;
	m_Capacity = size + MIN_CAPACITY;
	obj = new Object[size+MIN_CAPACITY];
}

template<class Object>
Vector<Object>::Vector(const Vector &rhs)
{
	m_Size = rhs.m_Size;
	m_Capacity = rhs.m_Capacity;
	obj = new Object[rhs.m_Capacity];
	for(int i=0; i<rhs.m_Capacity; ++i)
	{
		obj[i] = rhs.obj[i];
	}
}

template<class Object>
Vector<Object>::~Vector()
{
	delete []obj;
}

template<class Object>
const Vector<Object> &Vector<Object>::operator=(const Vector &rhs)//赋值函数
{
	m_Size = rhs.m_Size;
	m_Capacity = rhs.m_Capacity;
	obj = new Object[rhs.m_Capacity];
	for(int i=0; i<rhs.m_Capacity; ++i)
	{
		obj[i] = rhs.obj[i];
	}

	return *this;
}

template<class Object>
void Vector<Object>::resize(int newSize)
{
	if(newSize > m_Capacity)
	{
		reserve(2*newSize + 1);//其中一种解决方案，可以有其他不同的写法
	}
	m_Size = newSize;
}

template<class Object>
void Vector<Object>::reserve(int newCapacity)
{
	if(newCapacity < m_Size)
	{
		return ;
	}
	else
	{
		Object *oldObj = obj;
		obj = new Object[newCapacity];
		for(int i=0; i<m_Size; ++i)
		{
			obj[i] = oldObj[i];
		}
		m_Capacity = newCapacity;
		delete []oldObj;
	}
}

template<class Object>
Object &Vector<Object>::operator[](int index)
{
	return obj[index];
}

template<class Object>
const Object &Vector<Object>::operator[](int index) const
{
	return obj[index];
}

template<class Object>
bool Vector<Object>::empty() const
{
	return (m_Size == 0);
}

template<class Object>
int Vector<Object>::size() const
{
	return m_Size;
}

template<class Object>
int Vector<Object>::capacity() const
{
	return m_Capacity;
}

template<class Object>
void Vector<Object>::push_back(const Object &x)
{
	if(m_Size == m_Capacity)
	{
		reserve(2*m_Capacity + 1);//其中一种解决方案，可以有其他不同的写法
	}
	obj[m_Size++] = x;
}

template<class Object>
void Vector<Object>::pop_back()
{
	m_Size--;
}

template<class Object>
const Object &Vector<Object>::back() const
{
	return obj[m_Size-1];
}

#endif