使用C++类模板实现动态数组

#include <iostream>
#include <string>

using namespace std;
//使用类模板实现动态数组！
template<typename T, int N>
class Array{
private:
	T* m_array;
	int m_len;
public:
	//构造函数，给数组申请空间
	Array() : m_array(new T[N]), m_len(N){}
	
	//拷贝构造函数
	template<int X>
	Array(const Array<T, X>& that)
	{
		m_len = that.size();
		m_array = new T[m_len];
		if (m_array == NULL)
		{
			cout << "have not enough free memory" << endl;
			return;
		}

		memset(m_array, 0, m_len);
		memcpy(m_array, that.get_data(), m_len*sizeof(T));
	}

	//重载 = 运算符，使得数组之间能够实现 = 操作！
	template<int Y>
	Array& operator = (const Array<T, Y>& other)
	{
		if (this != &other)
		{
			//为保证程序的可靠性，应该先用一个临时变量将数据复制成功之后再改变被赋值数组的值，
			//这样可以保证在程序运行出错时，原数组不会受影响
			array = new T[m_len];
			if (array == NULL)
			{
				cout << "have not enough free memory" << endl;
				return;
			}

			memset(array, 0, other.size());
			memcpy(array, other.get_data(), other.size()*sizeof(T));

			delete[] m_array;
			m_array = array;
			m_len = other.size();
		}

		return *this;
	}

	//重载下标运算符，使得下标运算符具有越界检测功能!
	T& operator[](int index)
	{
		if (index > m_len - 1)
		{
			cout << "Array out of range, 0 to " << (m_len - 1) << " is legitimate scope." << endl;
			return m_array[0];  //因为return的是m_array[0]，所以如果是在执行 = 操作，则数组第一位元素值就会发生变化！
		}

		return m_array[index];
	}

	//重载下标运算符，保证常数组也能实现相关操作
	T& operator[](unsigned int index) const
	{
		if (index > m_len - 1)
		{
			cout << "Array out of range, 0 to " << (m_len - 1) << " is legitimate scope." << endl;
			return m_array[0];
		}

		return m_array[index];
	}

	//用来扩大数组的容量
	Array* add_memory(unsigned int len)
	{
		//增加一个中间变量
		T* temp = new T[m_len + len];
		if (temp == NULL)
		{
			cout << "have not enough free!" << endl;
			return this;
		}
		//将原来的数据存储进这个中间变量中
		memset(temp, 0, (m_len + len) * sizeof(T));
		memcpy(temp, m_array, m_len*sizeof(T));
		//删除原来的数组指针，并将中间变量temp赋值给成员变量m_array;
		delete[] m_array;
		m_array = temp;
		m_len = m_len + len;
		return this;
	}

	int size() const
	{
		return m_len;
	}

	T* get_data() const
	{
		return m_array;
	}

	friend ostream& operator<<(ostream& os, const Array<T, N>& array)
	{
		for (int i = 0; i < array.size(); i++)
		{
			os << array[i] << " ";
			//保证输出格式
			if (!(i + 1 % 5))
			{
				os << endl;
			}
		}

		return os;
	}
};

int main()
{
	Array<int, 5> b;
	b[0] = 1;
	b[1] = 3;
	b[2] = 4;
	b[3] = 5;
	b[4] = 6;
	b[7] = 8;

	cout << b[0] << endl;
	cout << b << endl;

	Array<int, 2> a(b);

	cout << a << endl;
	cout << a.size() << endl;
	cout << b.size() << endl;

	b.add_memory(10);
	cout << b.size() << endl;
	cout << b << endl;

	Array<int, 5> c;
	c = b;
	cout << c << endl;
	cout << c.size() << endl;

	b[20] = 20;


	system("pause");
	return 0;
}