Кто может накидать пример динамического трёхмерного массива?

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<unistd.h>
#define n 3
#define max 10
int main()
{
int ***m;
m=(int***)malloc(n*sizeof(int**));
if(!m) exit(1);
for(int i = 0; i < n; i++)
{
m[i]=(int**)malloc(n*sizeof(int*));
if(!m[i]) exit(1);
}
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
{
m[i][j]=(int*)malloc(n*sizeof(int));
if(!m[i][j]) exit(1);
}
srand(time(NULL));
printf("Start 3d matrix:\n\n");
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
for(int k = 0; k < n; k++)
{
m[i][j][k]=rand()%max;
printf("%3d",m[i][j][k]);
}
printf("\n");
}
printf("\n\n");
}
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
free(m[i][j]);
free(m);

fflush(stdout);
sleep(5);
return 0;
}

#include <iostream>
#include <iomanip>
using namespace std;
void print(int*** box, size_t layers, size_t rows, size_t columns) {
for (size_t layer = 0; layer != layers; ++layer, cout << '\n')
for (size_t row = 0; row != rows; ++row, cout << '\n')
for (size_t column = 0; column != columns; ++column)
cout << setw(5) << box[layer][row][column];
}
int main() {
size_t layers = 3, rows = 5, columns = 7;
auto size_buffer = layers * rows * columns;
auto total_rows = layers * rows;
auto buffer = new(nothrow) int[size_buffer];
if (buffer != nullptr) {
auto matrix = new int* [total_rows];
auto box = new int** [layers];
for (size_t row = 0; row != total_rows; ++row) {
matrix[row] = buffer + columns * row;
}
for (size_t layer = 0; layer != layers; ++layer) {
box[layer] = &matrix[layer * rows];
}
auto value = 0;
for (size_t index = 0; index != size_buffer; ++index) {
buffer[index] = ++value;
}
print(box, layers, rows, columns);
delete[] buffer;
delete[] matrix;
delete[] box;
} else {
cout << "Could not allocate memory!\n";
}
cin.get();
}

Вот тебе пример без удаления, там выше есть уже.
const int A=3, B=5, C=10;
int ***m = new int**[A];
for(int i=0; i<A; i++)
{
m[i] = new int*[B];
for(int j=0; j<B; j++) m[i][j] = new int[C];
}

// а тут вывод, чтобы понять
for(int i=0; i<A; i++)
for(int j=0; j<B; j++)
for(int k=0; k<C; k++)
{
m[i][j][k] = i*B*C + j*C + k;
cout << m[i][j][k] << "; ";
}

Вот пример программы с трёхмерным динамическим массивом, вычисляющей что-то нужное. А конкретно здесь находятся узловые значения гармонической функции в параллелепипеде с заданными на шести его гранях температурами. На экран выводятся номер каждой тысячной итерации и температура в центральной точке. На скринах -результаты для числа узлов N=1000000 и N=10000000.
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std; double h; int m(double x)
{ int n = floor(x / h); return (n & 1) ? n : n + 1; }
int main()
{
double a, b, c, d1, d2, s, hx, hy, hz, u1, u2, u3,
u4, u5, u6, v; int i, j, k, l, nx, nxx, ny, nyy, nz, nzz, N;
cout << "N a b c u1 u2 u3 u4 u5 u6 » ";
cin >> N >> a >> b >> c >> u1 >> u2 >> u3 >> u4
>> u5 >> u6; h = cbrt((a * b * c) / N); cout <<
"h = " << setprecision(12) << fixed << setw(13)
<< h << endl; v = (u1 + u2 + u3 + u4 + u5 + u6) / 6.;
nx = m(a); ny = m(b); nz = m(c);
double ***u = new double **[nx];
for (i = 0; i < nx; i++) { u[i] = new double *[ny];
for (j = 0; j < ny; j++) u[i][j] = new double [nz]; }
hx = a / (nx - 1.); hy = b / (ny - 1.); hz = c / (nz - 1.);
nxx = nx - 1; nyy = ny - 1; nzz = nz - 1;
d1 = pow(hx / hy, 2); d2 = pow(hx / hz, 2);
s = 0.5 / (1. + d1 + d2); for (j = 0; j < ny; j++)
for (k = 0; k < nz; k++)
{ u[0][j][k] = u1; u[nxx][j][k] = u2; }
for (i = 1; i < nxx; i++) for (k = 0; k < nz; k++ )
{ u[i][0][k] = u3; u[i][nyy][k] = u4; }
for (i = 1; i < nxx; i++) for (j = 1; j < nyy; j++)
{ u[i][j][0] = u5; u[i][j][nzz] = u6; }
for (i = 1; i < nxx; i++) for (j = 1; j < nyy; j++)
for (k = 1; k < nzz; k++) u[i][j][k] = v;
for (l = 1; l < 100000; l++) { for (i = 1; i < nxx; i++)
for (j = 1; j < nyy; j++) for (k = 1; k < nzz; k++)
u[i][j][k] = (u[i - 1][j][k] +u[i + 1][j][k] + d1 *
(u[i][j - 1][k] + u[i][j + 1][k]) + d2 *
(u[i][j][k - 1] + u[i][j][k + 1])) * s; if (l % 1000 == 0)
cout << setw(6) << l << setw(20) <<
u[nx / 2][ny / 2][nz / 2] << endl; }
}

⟨•⟩ Вот интересно: неужели всем охота горбатиться, выделяя память сначала под линейный массив верхнего уровня, затем — под каждый линейный подмассив, наконец — под каждый подмассив подмассива???

Неужели всем лень вычислить, сколько места требуется для всего 3D-массива, чтобы одним вызовом выделить столько, сколько нужно? Ну а затем просто присваивать указателям соответствующие значения?

Как-то так

int main() {
int n = 5;
int ***a = new int**[n];
for (int i = 0; i < n; i++) {
a[i] = new int*[n];
for (int j = 0; j < n; j++) {a[i][j] = new int[n];}
}
//...
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {delete[] a[i][j];}
delete[] a[i];
}
delete[] a;
return 0;
}