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<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;
}