Discussion :

[deletme]

Bonjour à toutes et à tous,

La fatigue n'aidant pas, je bloque sur une mise en place d'une allocation et d'une libération dynamique d'un tableau 3D.



Le problème surgit lorsque je fais la libération de la mémoire. J'ai pourtant bien essayé de respecter la règle un free pour un malloc :

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
33
34
35
36
37
int*** allocate3Darray(int stack, int width, int height){
 
    int ***ptr;
    int i, j;
 
    ptr = malloc (stack * sizeof (**ptr));
    if( ptr == NULL){
        return NULL;
    }
 
   //for (i = 0; i < width; i++){
        for (i = 0; i < stack; i++){
        ptr[i] = malloc( width * sizeof(*ptr));
        if(ptr[i] == NULL){
            for(--i ; i >=0; --i)
                free(ptr[i]);
 
            free(ptr);
            return NULL;
        }
       //for (j = 0; j < height; j++){
        for (j = 0; j < width ; j++){
            ptr[i][j] = malloc (height * sizeof (ptr));
            if (ptr[i][j] == NULL){
                for(--j; j >= 0 ; --j)
                    free(ptr[i][j]);
                for(--i ; i >=0; --i)
                    free(ptr[i]);
 
                free(ptr);
                return NULL;
            }
        }
    }
 
    return ptr;
}

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
//void  free3Darray(int ***ptr, int width, int height){
void  free3Darray(int ***ptr, int stack, int width){
 
    int i, j;
 
    //for (i = 0; i < width; i++){
    for (i = 0; i < stack; i++){
        //for (j = 0; j < height; j++)
        for (j = 0; j < width; j++)
            free(ptr[i][j]);
        free(ptr[i]);
    }
 
 
    free(ptr);
 
}

En utilisation :

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
33
34
35
36
37
38
39
40
41
#include <stdio.h>
#include <stdlib.h>
 
 
int main()
{
    int ***arr3d;
    int **arr2d;
    int x, y, z, count = 0;
 
 
    arr3d = allocate3Darray(2, 3, 3);
 
    if(arr3d == NULL) return EXIT_FAILURE;
 
    for( x = 0; x < 2 ; x++){
        for( y = 0; y < 3; y ++){
            for( z = 0; z < 3; z ++){
                arr3d[x][y][z] = count;
                count ++;
            }
        }
    }
 
    arr2d = &arr3d[1][0];
 
    for( x = 0; x < 3 ; x++){
        for( y = 0; y < 3; y ++){
            printf("%d ", arr2d[x][y]);
        }
        printf("\r\n");
    }
    printf("\r\n");
 
 
    arr2d = NULL;
    //free3Darray(arr3d, 3, 3);
    free3Darray(arr3d, 2, 3)
 
 
    return 0;

A la première exécution, pas de problème. Pour les suivantes, ça plante littéralement lors de la libération (dernier free()). Pas de message très exploitable du debugger.


J'ai vu qu'un autre sujet proposait une solution mais j'aimerai comprendre où je faute.

EDIT : Le problème venait simplement de mon parcours de boucle lors de l'allocation ET de la libération qui ne suivait aucune logique ...

[Obsidian]

Bonjour,
Pour ce genre de problème, il faut avoir le réflexe d'utiliser valgrind. Non seulement cela t'épargnera pas mal de maux de têtes, mais cela te permettra également d'être sûr de ne passer à côté de rien, ce qui est extrêmement difficile à garantir dans ce genre de situation, même pour des développeurs expérimentés.

Mais d'ores et déjà, il y a des choses étranges dans tes entêtes de boucle :

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
    for (i = 0; i < width; i++){
        ptr[i] = malloc( width * sizeof(*ptr));
        if(ptr[i] == NULL){
            for(--i ; i >=0; --i)
                free(ptr[i]);

            free(ptr);
            return NULL;
        }
        for (j = 0; j < height; j++){
            ptr[i][j] = malloc (height * sizeof (ptr));
            if (ptr[i][j] == NULL){
                for(--j; j >= 0 ; --j)
                    free(ptr[i][j]);
                for(--i ; i >=0; --i)
                    free(ptr[i]);

                free(ptr);
                return NULL;
            }
        }
    }

Les initialisations ne sont vraisemblablement pas celles que tu voulais écrire, et tu réutilises les mêmes noms de variable sans redéfinir celles-ci en local. Donc tes affectations peuvent avoir lieu n'importe où.

[Matt_Houston]

Sans compter l'habituelle question à propos des choix de conception : pourquoi un « tableau » 2D, 3D .. *D dynamique ?

[deletme]

Bonjour,
Pour ce genre de problème, il faut avoir le réflexe d'utiliser valgrind. Non seulement cela t'épargnera pas mal de maux de têtes, mais cela te permettra également d'être sûr de ne passer à côté de rien, ce qui est extrêmement difficile à garantir dans ce genre de situation, même pour des développeurs expérimentés.

Mais d'ores et déjà, il y a des choses étranges dans tes entêtes de boucle :

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
    for (i = 0; i < width; i++){
        ptr[i] = malloc( width * sizeof(*ptr));
        if(ptr[i] == NULL){
            for(--i ; i >=0; --i)
                free(ptr[i]);

            free(ptr);
            return NULL;
        }
        for (j = 0; j < height; j++){
            ptr[i][j] = malloc (height * sizeof (ptr));
            if (ptr[i][j] == NULL){
                for(--j; j >= 0 ; --j)
                    free(ptr[i][j]);
                for(--i ; i >=0; --i)
                    free(ptr[i]);

                free(ptr);
                return NULL;
            }
        }
    }

Les initialisations ne sont vraisemblablement pas celles que tu voulais écrire, et tu réutilises les mêmes noms de variable sans redéfinir celles-ci en local. Donc tes affectations peuvent avoir lieu n'importe où.

Bonjour,

Je reprends les mêmes variables car je souhaite pointer vers l'avant dernière allocation réussie pour libérer toutes les autres avant de quitter. Les boucles en question ne sont effectives qu'en cas d'erreur lors de l'allocation dynamique. Que me conseillez-vous ?

[dalfab]

Bonjour,

Au moment des allocations, il faut réserver malloc( NbElements * sizeof(*PointeurInitialisé) ). Copier 100 fois cette ligne.
Ligne 6, remplacer ptr = malloc (stack * sizeof (**ptr)); par ptr = malloc( stack * sizeof(*ptr) );.
Ligne 13, remplacer ptr[i] = malloc( width * sizeof(*ptr)); par ptr[i] = malloc( width * sizeof(**ptr) );.
Ligne 23, remplacer ptr[i][j] = malloc (height * sizeof (ptr)); par ptr[i][j] = malloc( height * sizeof(***ptr) );.C'est cette ligne qui alloue des entiers, nous avons bien quelque chose qui contiendra des tas d'entiers!

Ce qui est libéré en cas d'échec du 3ième malloc est insuffisant (il faut libérer les [i][0..j-1] du i courant, ok. Il faut libérer tous les indices [0..i-1][0..height-1], oubliés. Il faut libérer les indices [0..i], ok. Il faut libérer le ptr, ok.)

Mais aucune de ces erreurs ne devrait provoquer de plantage immédiat (il y trop de mémoire allouée). Qu'entends tu par "à la première exécution"? Le code est-il complet?

[Obsidian]

Bonjour,

Au moment des allocations, il faut réserver malloc( NbElements * sizeof(*PointeurInitialisé) ). Copier 100 fois cette ligne.

Quitte à copier 100 fois les choses pour les enregistrer, pourrais-tu en profiter pour retirer les parenthèses inutiles à sizeof ? Ça ne mange certes pas de pain, mais c'est une bonne chose de rappeler qu'elles ne font pas partie de la syntaxe obligatoire définie par la grammaire du langage.

Sans compter l'habituelle question à propos des choix de conception : pourquoi un « tableau » 2D, 3D .. *D dynamique ?

Oui, il y a fait référence à la fin de son post.

[dalfab]

Quitte à copier 100 fois les choses pour les enregistrer, pourrais-tu en profiter pour retirer les parenthèses inutiles à sizeof ? Ça ne mange certes pas de pain, mais c'est une bonne chose de rappeler qu'elles ne font pas partie de la syntaxe obligatoire définie par la grammaire du langage.

Tout à fait, mais je me suis souvent fait reprendre quand je ne les mets pas, cela donne une syntaxe perturbante.

Je précise donc, sizeof nécessite des parenthèses si on lui passe un type ou si on lui passe une expression de niveau supérieur à une expression unaire.

Code :

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

1
2
3
4
5
sizeof(int)     // parenthèses nécessaires
sizeof*ptr      // pas besoin des parenthèses
sizeof*pt->nbr  // pas besoin des parenthèses, on veut sizeof(*pr->mbr)
sizeof*ptr*2    // parenthèses non nécessaires car on veut 2 fois le type pointé donc sizeof(*ptr)*2.
sizeof(x + 1.f) // parenthèses nécessaires (on veut la taille du type qui sera float si x est entier, le type de x sinon!)

[Matt_Houston]

Oui, il y a fait référence à la fin de son post.

Oui, j'ai référencé l'autre fil parce qu'il était incidemment actif au même moment. Cependant ma remarque est plus générale : on voit passer des implémentations de matrices / tableaux multi-dimensionnels dynamiques par dizaines sur le forum alors qu'en production (en tout cas dans mon domaine : jeux, 2D/3D, réseau..) ce type de structure est plus qu'anecdotique.

Je suppute que c'est une manière d'entraîner les étudiants à la manipulation des différents niveaux d'indirection, mais ça participe parfois à leur donner de mauvais réflexes de conception..

[deletme]

Bonjour,

Une proposition de correction pour la libération du 3ème malloc :

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
for (i = 0; i < stack; i++){
        ptr[i] = malloc( width * sizeof(**ptr));
        if(ptr[i] == NULL){
            for(--i ; i >=0; --i)
                free(ptr[i]);
 
            free(ptr);
            return NULL;
        }
        for (j = 0; j < width; j++){
            ptr[i][j] = malloc (height * sizeof (***ptr));
            if (ptr[i][j] == NULL){
                for(--j; j >= 0 ; --j) // libération du dernier tuple i,j alloué
                    free(ptr[i][j]);
 
                free(ptr[i]);
 
                for( i ; i >=0; --i){
                    for (j = width -1 ; j >=0 ; j--)
                        free(ptr[i][j]);
 
                    free(ptr[i]);
                }
                free(ptr);
                return NULL;
            }
        }
    }

Oui, j'ai référencé l'autre fil parce qu'il était incidemment actif au même moment. Cependant ma remarque est plus générale : on voit passer des implémentations de matrices / tableaux multi-dimensionnels dynamiques par dizaines sur le forum alors qu'en production (en tout cas dans mon domaine : jeux, 2D/3D, réseau..) ce type de structure est plus qu'anecdotique.

Selon vous, il est préférable d'opter pour la solution donnée dans le thread cité dans mon 1er post ?

[Matt_Houston]

Non selon moi, il est préférable de manipuler un tableau à une seule dimension. Un seul malloc, un seul free, des éléments contigüs, c'est clair et cache-friendly.

Le fil que tu as référencé contient des informations pour continuer à adresser le buffer de manière « multi-dimensionnelle », si tu le souhaites.

[dalfab]

La linéarisation des tableaux multidimensionnels simplifie quand même beaucoup les problèmes d'allocations. Si les dimensions étaient connues à la compilation, un tableau de tableaux seraient alors peut-être une solution envisageable.

Pour ton code, attention tu libères deux fois le ptr[i], ligne 18, il faut plutôt for( --i ; i >=0; --i)

[ternel]

Tu peux aller plus loin avec une petite structure dédiée au stockage d'un tel tableau:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef struct {
int * data;
size_t d1, d2, d3;
} tab3i;
 
tab3i make_tab3i(size_t d1, d2, d3);
void destroy_tab3i(tab3i *);//pointeur non constant, pour mettre data à NULL dans l'objet pointé, en plus du delete
void clear_tab3i(tab3i *);
 
int tab3i_get(tab3i const*, size_t i1, size_t i2, size_t i3);
void tab3i_set(tab3i const*, size_t i1, size_t i2, size_t i3, value);
 
int* tab3i_getptr(tab3i*, size_t i1, size_t i2, size_t i3);

[deletme]

Ok, merci à tous d'avoir pris le temps de répondre à ce problème.