more effective c++——Item M30 代理类（一）多维数组的实现

代理类：用一个类来实现我们所需要的而 C++语言中并没有提供的东西，用户并不需要该类的具体实现

总结：

1.模板类中，输入输出操作符重载不能在模板类外部实现

2.数组类需要提供基本的操作：单参构造，拷贝构造，赋值操作，输出操作符

3.n维数组类持有n-1维数组的二级指针

4.多维数组可以看作n-1维数组的叠加，构造时需要先构造row个n-1个维数组的指针，然后再次为这些指针分配空间，析构时先删除n-1维数组的内存，再删除存放指针的内存

5.不要模板类型——typename

一维数组的实现：

#pragma once

#include <iostream>
//#include <afx.h>

using namespace std;

template<typename T>
class Array1D {
public:
Array1D(const int size) :m_isize(size), m_array(new T[m_isize]) {}
~Array1D() {
delete[] m_array;
}

Array1D<T> & operator=(const Array1D<T> &rhl);
const T & operator[](const int index) const;
T & operator[](const int index);

friend ostream &operator<< (ostream & os, const Array1D<T> &rhl)
{
for (int i = 0; i < rhl.m_isize; ++i)
{
cout << rhl[i];
if (i != rhl.m_isize - 1)
{
cout << "   ";
}
}
cout << endl;
return os;
}
private:
int m_isize;
T *m_array;
};

template<typename T>
inline Array1D<T> & Array1D<T>::operator=(const Array1D<T> &rhl)
{
if (m_array == rhl.m_array)
{
return *this;
}
delete[] m_array;
m_isize = rhl.m_isize;
m_array = new T[m_isize];
for (int i = 0;i < m_isize;++i)
{
m_array[i] = rhl.m_array[i];
}
return *this;
}

template<typename T>
inline const T & Array1D<T>::operator[](const int index) const
{
return m_array[index];
}

template<typename T>
inline T & Array1D<T>::operator[](const int index)
{
return m_array[index];
}

inline void test_array1d()
{
int isize = 10;
Array1D<int> arr1d(isize);

for (int i = 0; i < isize; ++i)
{
arr1d[i] = i * 2 + 1;
}

cout << arr1d;
}

二维数组的实现：

#pragma once
#include "Array1D.h"
#include <iostream>

using namespace std;

template<typename T>
class Array2D {
public:
Array2D(const int row,const int col) :m_irow(row), m_icol(col) {
m_array = new Array1D<T> *[m_irow];
for (int i = 0; i < m_irow;++i)
{
m_array[i] = new Array1D<T>(m_icol);
}
}
~Array2D() {
for (int i = 0; i < m_irow; ++i)
{
delete m_array[i];
}
delete[] m_array;
}

Array2D<T> & operator=(const Array2D<T> &rhl);
const Array1D<T> & operator[](const int index) const;
Array1D<T> & operator[](const int index);

friend ostream &operator<< (ostream & os, const Array2D<T> &rhl)
{
for (int i = 0; i < rhl.m_irow; ++i)
{
cout << rhl[i];
}
cout << endl;
return os;
}
private:
int m_irow;
int m_icol;
Array1D<T>  **m_array;
};

template<typename T>
inline Array2D
4000
<T> & Array2D<T>::operator=(const Array2D<T> &rhl)
{
if (m_array == rhl.m_array)
{
return *this;
}

for (int i = 0; i < m_irow; ++i)
{
delete m_array[i];
}

delete[] m_array;
m_irow = rhl.m_irow;
m_icol = rhl.m_icol;

m_array = new Array1D<T> *[m_irow];
for (int i = 0; i < m_irow; ++i)
{
m_array[i] = new Array1D<T>(m_icol);
*m_array[i] = *rhl.m_array[i];
}

return *this;
}

template<typename T>
inline const Array1D<T> & Array2D<T>::operator[](const int index) const
{
return *m_array[index];
}

template<typename T>
inline Array1D<T> & Array2D<T>::operator[](const int index)
{
return *m_array[index];
}

inline void test_array2d()
{
int row = 5;
int col = 7;
Array2D<int> arr2d(row,col);

for (int i = 0; i < row; ++i)
{
for (int j = 0 ;j < col;++j)
{
arr2d[i][j] = i + i*j;
}
}

cout << arr2d;
}

三维数组的实现：

#pragma once

#include "Array2D.h"

#include <iostream>

using namespace std;

template<typename T>
class Array3D {
public:
Array3D(const int len, int wid, int hight) :m_len(len), m_wid(wid), m_hight(hight)
{
m_array = new Array2D<T> *[len];
for (int i = 0;i < len;++i)
{
m_array[i] = new Array2D<T>(wid, hight);
}
}

~Array3D() {
for (int i = 0; i < m_len; ++i)
{
delete m_array[i];
}
delete[] m_array;
}

Array3D<T> & operator=(const Array3D<T> &rhl);
const Array2D<T> & operator[](const int index) const;
Array2D<T> & operator[](const int index);

friend ostream &operator<< (ostream & os, const Array3D<T> &rhl)
{
for (int i = 0; i < rhl.m_len; ++i)
{
cout << rhl[i];
}
cout << endl;
return os;
}
private:
int m_len;
int m_wid;
int m_hight;
Array2D **m_array;
};

template<typename T>
const Array2D<T> & Array3D<T>::operator[](const int index) const
{
return *m_array[index];
}

template<typename T>
inline Array2D<T>& Array3D<T>::operator[](const int index)
{
return *m_array[index];
}

template<typename T>
inline Array3D<T>& Array3D<T>::operator=(const Array3D<T>& rhl)
{
if (m_array == rhl.m_array)
{
return *this;
}

for (int i = 0; i < m_len; ++i)
{
delete m_array[i];
}

delete[] m_array;
m_len = rhl.m_len;
m_wid = rhl.m_wid;
m_hight = rhl.m_hight;

m_array = new Array2D<T> *[m_len];
for (int i = 0; i < m_irow; ++i)
{
m_array[i] = new Array2D<T>(m_wid,m_hight);
*m_array[i] = *rhl.m_array[i];
}
return *this;
}