C++类实现二维数组

样例已给出并完成一维数组的定义。起初以为要在一维的基础上对代码做修改，增加或变更数据成员和成员函数。但出现了不知道如何进行 Array2d[i][j]的问题。因为operator[]只能在类中对单个[]进行重载，这极大地限制了二维数组直接从一维变更的实现。

查阅思考无方。最后在百度知道获得启示，即建立一个另外的二维数组类，在类中添加元素为一维数组的大数组数据成员，可用指针表示。这样operator[]在重载时自顾自就好，原一维的可以分担一个[]。

一维数组类代码：

写在头文件arrayd1.h中。

#include<assert.h>
#include<iostream.h>
template <class T>
class Array1D
{
public:
		Array1D(int sz=0);
		~Array1D(){delete []elements;}
		T& operator [](int i)const;
		Array1D<T>&operator = (const Array1D<T> &r);
		friend istream &operator>>(istream &in, Array1D<T> &r);
		friend ostream &operator<<(ostream &out,const Array1D<T> &r);
private:
		int size;
		T *elements;
};

template <class T>
Array1D<T>::Array1D(int sz)
{
	assert(sz>=0);
	size=sz;
	elements = new T[sz];
}

template <class T>
T& Array1D<T>::operator [](int i)const
{	
	assert(i>=0 && i<size);
	return elements[i];
}

template <class T>
Array1D<T>& Array1D<T>::operator =(const Array1D<T> &r)
{
	if(this!=&r)
	{
		size = r.size;
		delete []elements;
		elements = new T[size];
		for(int i=0; i<size; i++)
		{
			elements[i] = r.elements[i];
		}
		
	}
	return *this;
}

template <class T>
istream &operator>>(istream &in, Array1D<T> &r)
{
	cout<<"Input array\n";
	for(int i=0; i<r.size; i++) in>>r.elements[i];
	return in;
}

template <class T>
ostream &operator<<(ostream &out, const Array1D<T> &r)
{
	cout<<"Array=";
	for(int i=0; i<r.size; i++) out<<r.elements[i]<<' ';
	out<<endl;
	return out;
}

重点是operator的使用。在上述过程和后续过程都对符号进行了重载。并且[] 和 = 以 T&为返回值。用了引用做返回值的函数。这么一来，函数既可以被直接使用，也可以在赋值=左右两边出现。可以传递函数生成并返回的值。这里的符号[] = 就可以让数组传值和赋值。

二维数组的代码：

写在头文件arrayd2.h中。

#include "arrayd1.h"
template <class T>
class Array2D
{
public:    
            Array2D(int row =0,int col = 0);
            ~Array2D();
            T& operator[](int i)const;
            Array2D<T>&operator=(const Array2D<T> &r);
            friend istream &operator>>(istream &in, Array2D<T> &r);
            friend ostream &operator<<(ostream &out, const Array2D<T> &r);
private:
            int Row;
            int Col;
            Array1D<T> *d2_elements;
};

template <class T>
Array2D<T>::Array2D(int row,int col)
{
	assert(col>=0 && row>=0);
	Row = row;
	Col = col;
	d2_elements = new Array1D<T>[Row];
	for(int i=0; i < Row; i++)
	{
		d2_elements[i] = Array1D<T>(Col);
	}
}

template <class T>
Array2D<T>::~Array2D()
{
	delete[] d2_elements;
}

template <class T>
T& Array2D<T>::operator [](int i)const
{
	assert(i>=0 && i<Row);
	return d2_elements[i];
}

template <class T>
Array2D<T>& Array2D<T>::operator=(const Array2D<T> &r)
{
	if(this!=&r)
	{
		Col = r.Col;
		Row = r.Row;
		int i=0,j=0;
		

                delete[] d2_elements;

		d2_elements = new Array1D<T>[r.Row]; 
		for(i=0; i<Row; i++)
		{
			d2_elements[i] = Array1D<T>(r.Col);
		}

		for(i=0; i<Row; i++)
		{
			for(j=0; j<Col; j++)
			{
				d2_elements[i][j] = r.d2_elements[i][j];
			}
		}
	}
	return *this;
}

template<class T>
istream &operator>>(istream &in, Array2D<T> &r)
{
	int i=0,j=0;
	for(i=0; i<r.Row; i++)
	{
		for(j=0; j<r.Col; j++)
		{
			in>>r.d2_elements[i][j];
		}
	}
	return in;
}

template <class T>
ostream &operator<<(ostream &out, const Array2D<T> &r)
{
	int i=0,j=0;
	cout<<"Array = "<<endl;
	for(i; i<r.Row; i++)
	{
		for(j=0; j<r.Col; j++)
		{
			out<<r.d2_elements[i][j]<<' ';
		}
		out<<endl;
	}
	return out;
}

d2_elements = new Array1D<T>[r.Row]; 类似这种，一定要区别new 类型名后跟的是[]还是()。前者创建数组，后者仅仅是（填上参数）表示创建单个对象的动态空间。在这里建立承载几个小一维数组的大数组才是我们需要的。

然后可以随便给出主函数，用来测试：

例子 main.cpp

#include "arrayd2.h"

void main()
{
	Array2D<int> a(3,4),b(3,4);
	cin>>a; cout<<"a "<<a;
	cin>>b; cout<<"b "<<b;
	b=a; cout<<"Result b is : "<<b;
}