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..