描述
实现一个三维数组模版CArray3D，可以用来生成元素为任意类型变量的三维数组，输出指定结果

#include <iostream>
#include <iomanip> 
#include <cstring>
using namespace std;
template <class T>
class CArray3D
{
// 在此处补充你的代码
};

CArray3D<int> a(3,4,5);
CArray3D<double> b(3,2,2);
void PrintA()
{
	for(int i = 0;i < 3; ++i) {
		cout << "layer " << i << ":" << endl;
		for(int j = 0; j < 4; ++j) {
			for(int k = 0; k < 5; ++k) 
				cout << a[i][j][k] << "," ;
			cout << endl;
		}
	}
}
void PrintB()
{
	for(int i = 0;i < 3; ++i) {
		cout << "layer " << i << ":" << endl;
		for(int j = 0; j < 2; ++j) {
			for(int k = 0; k < 2; ++k) 
				cout << b[i][j][k] << "," ;
			cout << endl;
		}
	}
}

int main()
{

	int No = 0;
	for( int i = 0; i < 3; ++ i ) {
		a[i];
		for( int j = 0; j < 4; ++j ) {
			a[j][i];
			for( int k = 0; k < 5; ++k )
				a[i][j][k] = No ++;
			a[j][i][i];	
		}
	}
	PrintA();
	memset(a[1],-1 ,20*sizeof(int));	
	memset(a[1],-1 ,20*sizeof(int));
	PrintA(); 
	memset(a[1][1],0 ,5*sizeof(int));	
	PrintA();

	for( int i = 0; i < 3; ++ i )
		for( int j = 0; j < 2; ++j )
			for( int k = 0; k < 2; ++k )
				b[i][j][k] = 10.0/(i+j+k+1);
	PrintB();
	int n = a[0][1][2];
	double f = b[0][1][1];
	cout << "****" << endl;
	cout << n << "," << f << endl;
		
	return 0;
}

输入
无
输出
等同于样例
样例输入
无
样例输出

layer 0:
0,1,2,3,4,
5,6,7,8,9,
10,11,12,13,14,
15,16,17,18,19,
layer 1:
20,21,22,23,24,
25,26,27,28,29,
30,31,32,33,34,
35,36,37,38,39,
layer 2:
40,41,42,43,44,
45,46,47,48,49,
50,51,52,53,54,
55,56,57,58,59,
layer 0:
0,1,2,3,4,
5,6,7,8,9,
10,11,12,13,14,
15,16,17,18,19,
layer 1:
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
layer 2:
40,41,42,43,44,
45,46,47,48,49,
50,51,52,53,54,
55,56,57,58,59,
layer 0:
0,1,2,3,4,
5,6,7,8,9,
10,11,12,13,14,
15,16,17,18,19,
layer 1:
-1,-1,-1,-1,-1,
0,0,0,0,0,
-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,
layer 2:
40,41,42,43,44,
45,46,47,48,49,
50,51,52,53,54,
55,56,57,58,59,
layer 0:
10,5,
5,3.33333,
layer 1:
5,3.33333,
3.33333,2.5,
layer 2:
3.33333,2.5,
2.5,2,
****
7,3.33333

提示
建议做法：

1. a[i][j][k] 这个表达式的第一个[]返回一个内部类的对象，该内部类也重载了[],且返回值为指针。
2. 必要时需重载对象到指针的强制类型转换运算符

解题
先复习二维数组的做法，
即建立初始数组 a[i * j]，大小为二维数组大小，
找寻 a[n][0] 地址即为 a[n * j]；
找寻a[n][m]即为a[n * j][m];
由此考虑三维数组的表示方法——构建指针T *p = new T [i * j * k]；

故先定义共有成员——ijk以及指针 * p
构造函数—— * p的赋值；

public:
int i;
int j;
int k;
T *p; 

CArray3D(int a, int b, int c){
	i=a;
	j=b;
	k=c;
	p=new T[i*j*k];
}

 ~CArray3D() { delete [] p; }

先考虑实现三维数组内的二维数组
构造类中类Aid；
成员函数 ip为该二维数组的起始地址——即三维数组的 * (ip)= * (p + i * j * k])；
成员函数 k每列的元素——即二维数组的a[i][j]=* (ip+j*k)中所需的k ；
得到这俩再后面添加第三个括号即可得到三维数组的地址。

class Aid {
	public:
		T * ip;      //指向i层元素的起始地址 
		int k;        //每个j层有k个元素
		
		Aid(T* a, int b):ip(a),k(b){}   //构造函数 
		
		T* operator [](int j){     //重构【】 , 返回指针——及第三维的数组指针
		//第二个框——到j行，返回j行的开头位置
		//再调用第三个框——即可得到j行的第k个位置了 
			return ip+j*k;       //返回i层的j行的起始位置 
		}
		
		//类型转换运算符重载，将对象转换成T *类对象，不写返回值类型 
		operator T *(){        // T* a[i]，返回a[i]的ip,类型为T* 
			return ip;      //ip表示第i行的起始位置——故a[1]对象可被强制转换为起始位置指针 
		}
};

重载CArray3D的[ ]符号
重载返回值为类中类Aid，且附上参数——ip，k
ip = p+i * j * k；
k = k；

Aid operator[](int i) {        //a[i],返回Aid对象 
	T * ip =p+i*j*k;			//第一个框——到第i层 
	return Aid(ip,k);      //每层j行，每行k个元素      
}

完整代码

class CArray3D
{
//实现一个三维数组模版CArray3D，
//可以用来生成元素为任意类型变量的三维数组，输出指定结果
// 在此处补充你的代码
//建议做法：
//1. a[i][j][k] 这个表达式的第一个[]返回一个内部类的对象，该内部类也重载了[],且返回值为指针。
//2. 必要时需重载对象到指针的强制类型转换运算符

public:
int i;
int j;
int k;
T *p; 

CArray3D(int a, int b, int c){
	i=a;
	j=b;
	k=c;
	p=new T[i*j*k];
}

 ~CArray3D() { delete [] p; }

class Aid {
	public:
		T * ip;      //指向i层元素的起始地址 
		int k;        //每个j层有k个元素
		
		Aid(T* a, int b):ip(a),k(b){}   //构造函数 
		
		T* operator [](int j){     //重构【】 , 返回指针——及第三维的数组指针
		//第二个框——到j行，返回j行的开头位置
		//再调用第三个框——即可得到j行的第k个位置了 
			return ip+j*k;       //返回i层的j行的起始位置 
		}
		
		
		//类型转换运算符重载，将对象转换成T *类对象，不写返回值类型 
		operator T *(){        // T* a[i]，返回a[i]的ip,类型为T* 
			return ip;      //ip表示第i行的起始位置——故a[1]对象可被强制转换为起始位置指针 
		}
};

Aid operator[](int i) {        //a[i],返回Aid对象 
	T * ip =p+i*j*k;			//第一个框——到第i层 
	return Aid(ip,k);      //每层j行，每行k个元素      
}
//
};