Vector

#ifndef _MYVECTOR_H
#define _MYVECTOR_H

// explicit 关键字的作用是怕隐式转换,针对单参构造函数
// const 加在函数的最后面是告诉调用者这个函数不能改变该类的内部成员变量

//#define CAPACITY (20)

template<typename T>
class Vector
{
public:
	// 构造
	explicit Vector(const int iInit = 0) : 
		 m_iCount(iInit), m_iCapacity(iInit + CAPACITY)
	{
		m_pVector = new T[m_iCapacity];
	}

	// 析构
	~Vector()
	{
		delete [] m_pVector;
	}

	// 拷贝构造
	Vector(const Vector & vParam) : m_pVector(NULL)
	{
		operator=(vParam);
	}

	// =运算符
	const Vector&  operator=(const Vector & vParam) 
	{
		if (this != &vParam)
		{
			// 删除之前的内存
			delete [] m_pVector;

			// 其他变量的赋值
			m_iCapacity = vParam.m_iCapacity;
			m_iCount = vParam.m_iCount;

			// 创建内存
			m_pVector = new T[m_iCapacity];

			// 拷贝数据
			memcpy(m_pVector, vParam.m_pVector, sizeof(T) * m_iCount);
		}

		return *this;
	}
public:
	int Size() const
	{
		return m_iCount;
	}

	int Capacity() const
	{
		return m_iCapacity;
	}

public:
	// 增加容量
	void Reserve(int iNewCapacity)
	{
		int iOldCapacity = m_iCapacity;
		T *pOldVector = m_pVector;

		if(iNewCapacity > iOldCapacity)
		{
			m_iCapacity = iNewCapacity;
			m_pVector = new T[iNewCapacity];
			memcpy(m_pVector, pOldVector, sizeof(T) * m_iCount);
			delete [] pOldVector;
		}
	}
public:
	void push_back(const T& val)
	{
		// 如果超过了容量
		if (m_iCount == m_iCapacity)
		{
			Reserve(m_iCapacity + CAPACITY);
		}

		m_pVector[m_iCount++] = val;
	}

	void pop_back()
	{
		if (m_iCount > 0)
		{
			m_iCount--;
		}
	}
public:
	T& operator[](int iIndex)
	{
		return m_pVector[iIndex];
	}

	const T& operator[](int iIndex) const
	{
		return m_pVector[iIndex];
	}

public:
	typedef T* Iterator;
	typedef const T* Const_Iterator;

	Iterator Begin()
	{
		return m_pVector;
	}

	Iterator End()
	{
		return (m_pVector + m_iCount);
	}

	Const_Iterator Begin() const
	{
		return m_pVector;
	}

	Const_Iterator End() const
	{
		return (m_pVector + m_iCount);
	}

private:
	enum{CAPACITY = 20};
private:
	int m_iCount;
	int m_iCapacity;
	T *m_pVector;
};


#endif