Pointer do 3-wym. array

Cześć.
Piszę klasę zawierającą funkcję, która tworzy 3-wymiarowy array o określonych rozmiarach.
Obecnie mam problem ponieważ nie wiem w jaki sposób utworzyć pointer do 3-wymiarowego array'a.
Pointer do 3-wymiarowego array'a jest mi potrzebny, aby móc przepuścić go przez funkcję.
Proszę o pomoc.

<typ twojej tablicy> ***p_3d_tab;

Czy możesz napisać dokładniej w jaki sposób utworzyć pointer do 3d array?
Najlepiej na jakimś przykładzie.

void func( int ***tab );

int ***tab = new int**[10];
for( int i = 0; i < 10; i++ ) {
 tab[i] = new int*[10];
 for( int o = 0; o < 10; o++ )
  tab[i][o] = new int[10];
}

func(tab);

for( int i = 0; i < 10; i++ ) {
 for( int o = 0; o < 10; o++ )
  delete [] tab[i][o];
 delete [] tab[i];
}

delete [] tab;

Dziękuję za pomoc.
Byłem na bust, na pewno będę z niego korzystać.
Mam kolejny problem.
Dlaczego poniższa klasa się zawiesza gdy jej użuwam?
Podejrzewam, że chodzi o metodę mesh_grid.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <math.h>
#include <string>
#include <vector>

using namespace std;

//klasa dekompozuje przestrzeń
typedef float (*Mesh)[1000][1000][1000];

class discritizer {
private:
float *iter_x, *iter_y, *iter_z;
int *size_x, *size_y, *size_z;
double Ixyz[3];
const int i,j,k;
float A[3];
public:
float u;
int l_x;
int l_y;
int l_z;
double Num_elem;
double discrete();
double knot_handle();
double num_elements()
{
return (Num_elem = l_xl_yl_z);
}
Mesh mesh_grid();
discritizer(float iterX, float iterY, float iterZ, int sizeX, int sizeY, int sizeZ);
~discritizer();
};

double *discritizer::discrete()
{
double l_x = *size_x/ *iter_x;
double l_y = *size_y/ *iter_y;
double l_z = *size_z/ *iter_z;
double *Ixyz = new double[3] = {l_x, l_y, l_y};
return (Ixyz);
}

double *discritizer::knot_handle()
{
double A = new double[3] = {i iter_x, j iter_y, k *iter_z};
return A;
}

Mesh discritizer::mesh_grid()
{

Mesh D;
int i,j,k;
for(k=0; k<l_z; k++) {
for(j=0; j<l_y; j++) {
for(i=0; i<l_x; i++) {
(*D)[i][j][k] = u; }}}
return D;
}

discritizer::discritizer(float iterX, float iterY, float iterZ, int sizeX, int sizeY, int sizeZ)
{
iter_x = new float;
iter_y = new float;
iter_z = new float;
size_x = new int;
size_y = new int;
size_z = new int;
*iter_x = iterX;
*iter_y = iterY;
*iter_z = iterZ;
*size_x = sizeX;
*size_y = sizeY;
*size_z = sizeZ;
}

discritizer::~discritizer() {
delete iter_x;
delete iter_y;
delete iter_z;
delete size_x;
delete size_y;
delete size_x;
}

a po co dynamicznie tworzysz wartości??

Faktycznie, może dynamiczne tworzenie wartości nie jest tu potrzebne ale czy to coś zmieni?

dynamiczne tworzenie wartości miało się przydać póżniej

a jak tego używasz??