Discussion :

[galadorn]

voila mon problème : je suis débutant dans ce langage donc je suis un peu perdu.
je dois construire un tableau a trois dimension de taille environ [512][512][50] minimum. ça compile parfaitement , mais le programme ferme a l'execution. je soupçonne de mettre ma mémoire en overflow avec ce tableau.
une idée pour résoudre ce problème ?

[aiolia_aiolos]

voila mon problème : je suis débutant dans ce langage donc je suis un peu perdu.
je dois construire un tableau a trois dimension de taille environ [512][512][50] minimum. ça compile parfaitement , mais le programme ferme a l'execution. je soupçonne de mettre ma mémoire en overflow avec ce tableau.
une idée pour résoudre ce problème ?

En effet ça me parait bcp, essaye d'allouer la mémoire dynamiquement.

[galadorn]

comment faire ?

[koala01]

Salut,

Tu as la solution d'allouer la mémoire dynamique "à la barbare" (à la manière "C style") sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int main()
{
    int ***tab3D= new int**[512];
    for(size_t i = 0;i<512;++i)
    {
        tab3D[i]= new int*[512];
        for(size_t j = 0;j<512;++j)
            tab3D[i][j]=new int[50];
    }
    /* utilisation de ton tableau */
 
    /* !!! ne pas oublier de libérer la mémoire quand tu n'en a plus besoin !!!*/
    for(size_t i = 0;i<512;++i)
    {
        for(size_t j=0;j<512;++j)
        {
            delete tab3D[i][j];
        }
        delete tab3D[i];
    }
    delete tab3D;
    tab3D = NULL;
    return 0;
}

Mais, honnetement, je te le déconseille fortement (les pointeurs et l'allocation dynamique, d'est déjà pas gai, mais, alors, les pointeurs de pointeurs et, pire, les pointeur de pointeur de pointeurs... c'est carrément suicidaire )

Ce que je te conseillerais plutôt, c'est de te rappeler que ton tableau doit contenir X * Y * Z éléments (ou X représente la première dimension, X la deuxième et Z la troisième)

et d'envisager une fonction qui te permette d'accéder à la variable x, y, z sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int valueAt(size_t x, size_t y, size_t z)
{
    return tab[(x*maxY*maxZ)+(y*maxZ)+z];
}

ou maxY et maxZ représentent respectivement... la taille des dimensions Y et Z

Une fois ce principe accepté, il ne te reste plus qu'à créer une classe qui le fasse correctement, soit à l'aide d'un tableau "C style", qui prendrait une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Tab3D
{
    public:
        Tab3D(size_t maxX, size_t maxY, size_t maxZ):maxX(maxX),
                                                      maxY(maxY),
                                                      maxZ(maxZ)
                                                      tab(0)
        {
             /* aucune dimension ne peut contenir... 0 élément */ 
            if(maxX==0||maxY==0 ||maxZ==0)
                throw BadDimSize(); // à implémenter à ta guise 
            tab=new int(maxX*maxY*maxZ);
        }
        ~Tab3D()
        {
            delete tab;
            tab = 0;
        }
        int valueAt(size_t x, size_t y, size_t z)
        {
            /* idéalement, il faudrait gérer le fait que x, y ou z doivent
             * etre compris respectivement entre 0 et maxX, maxY et maxZ
             */
            return tab[(x*maxY*maxZ)+(y*maxZ)+z];
        }
        /* d'autres méthodes utiles, mais non précisées ici */
    private:
        size_t maxX;
        size_t maxY;
        size_t maxZ;
        int *tab;
};

C'est déjà mieux, mais bon, cela t'oblige à gérer toi meme la mémoire dynamiquement, et c'est pas sympa...

Ne serait-ce que parce que tu devrais définir également le constructeur par copie et l'opérateur d'assignation, que je n'ai pas présentés ici

En outre, il serait quand même dommage de passer à coté des possibilités de la classe vector, disponible dans l'espace de noms std par inclusion du fichier d'en-tête vector, qui est fournie par la norme

Tu pourrais donc remplacer ton tableau "C style" par un objet de type std::vector, et cela prendrait donc la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Tab3D
{
    public:
        Tab3D(size_t maxX, size_t maxY, size_t maxZ):maxX(maxX),
                                                      maxY(maxY),
                                                      maxZ(maxZ)
                                                      tab(maxX*maxY*maxZ)
        {
             /* aucune dimension ne peut contenir... 0 élément */ 
            if(maxX==0||maxY==0 ||maxZ==0)
                throw BadDimSize(); // à implémenter à ta guise 
        }
        ~Tab3D()
        {
        }
        int valueAt(size_t x, size_t y, size_t z)
        {
            /* idéalement, il faudrait gérer le fait que x, y ou z doivent
             * etre compris respectivement entre 0 et maxX, maxY et maxZ
             */
            return tab[(x*maxY*maxZ)+(y*maxZ)+z];
        }
        /* d'autres méthodes utiles, mais non précisées ici */
    private:
        size_t maxX;
        size_t maxY;
        size_t maxZ;
        std::vector<int> tab;
};

NOTA: j'ai utilisé pour l'exemple des entiers, mais rien ne t'empêche d'utiliser d'autres types

[Davidbrcz]

Si la taille est connue à la compilation, regarde du coté de boost::multi_array.

[Montag]

Salut,

Juste quelques remarques sur le premier code de Koala (j'ai pas regardé le reste):
1) il y a plus simple puisque les dimensions sont connues:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int (*tab)[512][50]=new int[512][512][50];
//...
delete[] tab;

2) la solution proposée n'est pas exception-safe.
3) c'est delete[] qu'il faut utiliser et non delete.

[koala01]

Salut,

Juste quelques remarques sur le premier code de Koala (j'ai pas regardé le reste):
1) il y a plus simple puisque les dimensions sont connues:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int (*tab)[512][50]=new int[512][512][50];
//...
delete[] tab;

2) la solution proposée n'est pas exception-safe.

De fait... j'aurais du le préciser (j'y ai pensé, mais, pour finir, ca m'est sorti de la tête)

3) c'est delete[] qu'il faut utiliser et non delete.

Aussi... une distraction de ma part

[galadorn]

un tout tout grand merci a tout le monde,
le int (*tab)[512][50]=new int[512][512][50]; a l'air de fonctionner comme je le souhaite je vais donc partir vers cette piste la
je met le sujet en résolu, merci encor