C++——多维数组动态开辟与释放

前言

在讨论多维数组动态开辟与释放之前，先说说什么是二维数组静态开辟与释放。

形如这种就是静态开辟内存，事先画好了内存大小

#include<iostream>
using namespace std;

#define ROW 3
#define COL 4
int main()
{
    int ar[COL][ROW] = {  };
    return ;
}

使用二级指针模拟二维数组

代码演示

#include<iostream>
#include<assert.h>
using namespace std;

#define ROW 3
#define COL 4
int main()
{
    int **p=(int**)malloc(sizeof(int*)*ROW);
    assert(NULL != p);
    for (int i=;i<ROW;++i)
    {
        p[i] = (int*)malloc(sizeof(int)*COL);
        assert(NULL!=p[i]);
    }
    for (int i = ; i< ROW; ++i)
    {
        for (int j = ; j < COL; ++j)
        {
            p[i][j] = i + j;
        }
    }
    for (int i = ; i< ROW; ++i)
    {
        for (int j = ; j < COL; ++j)
        {
            cout << p[i][j]<<" ";
        }
        cout << endl;
    }
    return ;
}

这段代码有个问题，内存泄漏。

泄露内存大小为4*3 + 4*4*3 = 60 Byte。我们知道，进程的用户空间内存中有一段内存是程序运行时需要的（堆、栈、共享内存区），栈内存由OS动态开辟回收，我们malloc的内存时是在堆中，需要我们手动释放，否则就会内存泄露。

free(p)这么释放内存可以吗？

不可以，这么仅仅是把3个int*释放了，后面int*指向的内存泄露。

正确释放内存，先释放int*指向的内存，在释放p指向的内存（即3个int*内存）

 #include<iostream>
 #include<assert.h>
 using namespace std;

 #define ROW 3
 #define COL 4
 int main()
 {
     int **p=(int**)malloc(sizeof(int*)*ROW);
     assert(NULL != p);
     for (int i=;i<ROW;++i)
     {
         p[i] = (int*)malloc(sizeof(int)*COL);
         assert(NULL!=p[i]);
     }
     for (int i = ; i< ROW; ++i)
     {
         for (int j = ; j < COL; ++j)
         {
             p[i][j] = i + j;
         }
     }
     for (int i = ; i< ROW; ++i)
     {
         for (int j = ; j < COL; ++j)
         {
             cout << p[i][j]<<" ";
         }
         cout << endl;
     }
     for (int i=;i<ROW;++i)
     {
         free(p[i]);
     }
     free(p);
     return ;
 }

代码封装一下，malloc版本

 #include<iostream>
 #include<assert.h>
 using namespace std;
 #define Type int
 #define ROW 3
 #define COL 4

 Type** _Malloc(int row,int col)
 {
     Type **p = (Type**)malloc(sizeof(Type*)*row);
     assert(NULL != p);
     for (int i = ; i<row; ++i)
     {
         p[i] = (Type*)malloc(sizeof(Type)*col);
         assert(NULL != p[i]);
     }
     return p;
 }

 void _Assign(Type **p, int row, int col)
 {
     for (int i = ; i< row; ++i)
     {
         for (int j = ; j < col; ++j)
         {
             p[i][j] = i + j;
         }
     }
 }

 void _Print(Type **p, int row, int col)
 {
     for (int i = ; i< row; ++i)
     {
         for (int j = ; j < col; ++j)
         {
             cout << p[i][j] << " ";
         }
         cout << endl;
     }
 }

 void _Free(Type **p, int row)
 {
     for (int i = ; i<row; ++i)
     {
         free(p[i]);
     }
     free(p);
 }
 int main()
 {
     Type **p = _Malloc(ROW,COL);
     _Assign(p,ROW,COL);
     _Print(p, ROW, COL);
     _Free(p, ROW);
     return ;
 }

new版本

 #include<iostream>
 #include<assert.h>
 using namespace std;
 #define Type int
 #define ROW 3
 #define COL 4

 Type** _New(int row,int col)
 {
     Type **p = new Type*[row];
     assert(NULL != p); //C++一般不用断言，而是使用异常机制
     for (int i = ; i<row; ++i)
     {
         p[i] = new Type[col];
         assert(NULL != p[i]);
     }
     return p;
 }

 void _Assign(Type **p, int row, int col)
 {
     for (int i = ; i< row; ++i)
     {
         for (int j = ; j < col; ++j)
         {
             p[i][j] = i + j;
         }
     }
 }

 void _Print(Type **p, int row, int col)
 {
     for (int i = ; i< row; ++i)
     {
         for (int j = ; j < col; ++j)
         {
             cout << p[i][j] << " ";
         }
         cout << endl;
     }
 }

 void _Delete(Type **p, int row)
 {
     for (int i = ; i<row; ++i)
     {
         delete []p[i];
     }
     delete []p;
 }
 int main()
 {
     Type **p = _New(ROW,COL);
     _Assign(p,ROW,COL);
     _Print(p, ROW, COL);
     _Delete(p, ROW);
     return ;
 }

C++的常用做法

在C++里面开辟二维数组，实际上没有上面那么麻烦。在看懂下面代码之前，需要向理解下面的思想。

数组的首元数是谁，指向数组首元素的指针真么写？

对于一维数组，如下图，首元素就是整型。整型数组首元素的地址就是int*。所以一维数组接收地址就是一个整型指针int*。

对于二维数组，必然涉及到行和列，他的首元素就不再是其中单独一行的某一个元数，而是整体一行，首元素的地址就是（一维数组的地址）int**。所以二位数组接收地址就是int**,也就是说需要使用int**指向首元素，因为首元素是一维数组，数组是int*类型。

二维数组代码演示

 #include<iostream>
 #include<assert.h>
 using namespace std;
 #define Type int
 #define ROW 3
 #define COL 4

 //定义数组指针类型
 typedef Type(*Ar)[COL];
 Ar _New()
 {
     Ar p= new Type[ROW][COL];
     return p;
 }

 void _Assign(Ar p, int row, int col)
 {
     for (int i = ; i< row; ++i)
     {
         for (int j = ; j < col; ++j)
         {
             p[i][j] = i + j;
         }
     }
 }

 void _Print(Ar p, int row, int col)
 {
     for (int i = ; i< row; ++i)
     {
         for (int j = ; j < col; ++j)
         {
             cout << p[i][j] << " ";
         }
         cout << endl;
     }
 }

 void _Delete(Ar p)
 {
     delete []p;
 }
 int main()
 {
     Ar p = _New();
     _Assign(p,ROW,COL);
     _Print(p, ROW, COL);
     _Delete(p);
     return ;
 }

三维数组代码演示

 #include<iostream>
 #include<assert.h>
 using namespace std;
 #define Type int
 #define ROW 3
 #define COL 4
 #define Z 5

 //定义数组指针类型
 typedef Type(*Ar)[ROW][COL];
 Ar _New()
 {
     Ar p = new Type[Z][ROW][COL];
     return p;
 }

 void _Assign(Ar p, int row, int col, int z)
 {
     static int count = ;
     for (int i = ; i < row; ++i)
     {
         for (int j = ; j < col; ++j)
         {
             for (int k = ; k < z; ++k)
             {
                 p[i][j][k] = ++count;
                 cout.width();
                 cout.flags(ios::left);
                 cout << p[i][j][k] << " ";
             }
             cout << endl;
         }
         cout << endl;
     }
 }

 void _Print(Ar p, int row, int col, int z)
 {
     for (int k = ; k < z; ++k)
     {
         for (int i = ; i < row; ++i)
         {
             for (int j = ; j < col; ++j)
             {
                 cout.width();
                 cout.flags(ios::left);
                 cout << p[i][j][k] << " ";
             }
             cout << endl;
         }
         cout << endl;
     }
 }

 void _Delete(Ar p)
 {
     delete[]p;
 }
 int main()
 {
     Ar p = _New();
     _Assign(p, ROW, COL, Z);
     _Print(p, ROW, COL, Z);
     _Delete(p);
     return ;
 }