Ich kenne Algorithmen zum dynamischen Zuweisen / Freigeben eines 2D-Arrays, bin mir jedoch bei 3D-Arrays nicht so sicher.
Mit diesem Wissen und ein bisschen Symmetrie kam ich auf den folgenden Code.
(Es fiel mir schwer, während des Codierens in 3D zu visualisieren.)

Bitte kommentieren Sie die Richtigkeit und schlagen Sie gegebenenfalls eine bessere Alternative (effizient oder intuitiv) vor.
Ich denke auch, dass auf diese 2D- und 3D-Arrays normalerweise wie auf statische Arrays wie arr2D [2] [3] und zugegriffen werden kann
arr3D [2] [3] [2]. Recht?

Code für 2D

//allocate a 2D array
int** allocate2D(int rows,int cols)
{
    int **arr2D;
    int i;

    arr2D = (int**)malloc(rows*sizeof(int*));
    for(i=0;i<rows;i++)
    {
        arr2D[i] = (int*)malloc(cols*sizeof(int));
    }
}

//deallocate a 2D array
void deallocate2D(int** arr2D,int rows)
{
    int i;

    for(i=0;i<rows;i++)
    {
        free(arr2D[i]);
    }

    free(arr2D);
}  

Code für 3D

//allocate a 3D array
int*** allocate3D(int l,int m,int n)
{
int ***arr3D;
int i,j,k;

arr3D = (int***)malloc(l * sizeof(int **));

for(i=0;i<l;i++)
{
    arr3D[i] = (int**)malloc(m * sizeof(int*));
    for(j=0;j<m;j++)
    {
        arr3D[i][j] = (int*)malloc(n*sizeof(int));
    }
}

return arr3D;
}

//deallocate a 3D array
void deallocate3D(int arr3D,int l,int m)
{
    int i,j;

    for(i=0;i<l;i++)
    {
        for(int j=0;j<m;j++)
        {
            free(arr3D[i][j]);
        }
        free(arr3D[i]);
    }
    free(arr3D);
}