C++——多維數組動態開辟與釋放

前言

在討論多維數組動態開辟與釋放之前，先說說什么是二維數組靜態開辟與釋放。

形如這種就是靜態開辟內存，事先畫好了內存大小

#include<iostream>
using namespace std;

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

 

使用二級指針模擬二維數組

代碼演示

#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=0;i<ROW;++i)
    {
        p[i] = (int*)malloc(sizeof(int)*COL);
        assert(NULL!=p[i]);
    }
    for (int i = 0; i< ROW; ++i)
    {
        for (int j = 0; j < COL; ++j)
        {
            p[i][j] = i + j;
        }
    }
    for (int i = 0; i< ROW; ++i)
    {
        for (int j = 0; j < COL; ++j)
        {
            cout << p[i][j]<<" ";
        }
        cout << endl;
    }
    return 0;
}

這段代碼有個問題，內存泄漏。

泄露內存大小為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=0;i<ROW;++i)
    {
        p[i] = (int*)malloc(sizeof(int)*COL);
        assert(NULL!=p[i]);
    }
    for (int i = 0; i< ROW; ++i)
    {
        for (int j = 0; j < COL; ++j)
        {
            p[i][j] = i + j;
        }
    }
    for (int i = 0; i< ROW; ++i)
    {
        for (int j = 0; j < COL; ++j)
        {
            cout << p[i][j]<<" ";
        }
        cout << endl;
    }
    for (int i=0;i<ROW;++i)
    {
        free(p[i]);
    }
    free(p);
    return 0;
}

代碼封裝一下，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 = 0; 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 = 0; i< row; ++i)
    {
        for (int j = 0; j < col; ++j)
        {
            p[i][j] = i + j;
        }
    }
}

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

void _Free(Type **p, int row)
{
    for (int i = 0; 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 0;
}

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 = 0; 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 = 0; i< row; ++i)
    {
        for (int j = 0; j < col; ++j)
        {
            p[i][j] = i + j;
        }
    }
}

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

void _Delete(Type **p, int row)
{
    for (int i = 0; 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 0;
}

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 = 0; i< row; ++i)
    {
        for (int j = 0; j < col; ++j)
        {
            p[i][j] = i + j;
        }
    }
}

void _Print(Ar p, int row, int col)
{
    for (int i = 0; i< row; ++i)
    {
        for (int j = 0; 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 0;
}

三維數組代碼演示

#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 = 0;
    for (int i = 0; i < row; ++i)
    {
        for (int j = 0; j < col; ++j)
        {
            for (int k = 0; k < z; ++k)
            {
                p[i][j][k] = ++count;
                cout.width(5);
                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 = 0; k < z; ++k)
    {
        for (int i = 0; i < row; ++i)
        {
            for (int j = 0; j < col; ++j)
            {
                cout.width(5);
                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 0;
}