Modifier des tableaux dynamiques dans une fonction

Version imprimable

Bonsoir,
Je poste ce message pour avoir une aide sur les tableaux dynamiques. Je pense que c'est un problème de pointeur, mais je n'arrive pas à le résoudre.
J'ai besoin (pour un programme plus gros) de modifier deux tableaux dynamiques de la manière suivante :
etape 1 : definition d'un TableauInitial et d'un TableauFinal.
etape 2 : le TableauFinal devient le TableauInitial et définition d'un nouveau TableauFinal.

J'ai déjà fait une version1 qui fonctionne très bien. Sauf que le gros du travail se fait dans le main.
J'ai voulu transférer une partie du main dans une fonction, et là, le programme compile, mais plante.

version1 : qui fonctionne

Code:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <stdio.h>
#include <stdlib.h>
 
void AfficheTableau(int **Tableau, int N,int M)
{
    int i, j;
 
    for(i=0; i<N; i++)//affiche tableau
    {
        for(j=0; j<M; j++)
            printf("(%d)",Tableau[i][j]);
        printf("\n");
    }
    printf("\n");
    printf("\n");
}
 
/**********************/
int **FonctionAllocation2D(int dimension1, int dimension2)//alloue dynamiquement un tableau a deux dimensions
{
    int i;
    int **tableau;
 
    tableau=malloc((dimension1)*sizeof(*tableau));//on alloue  N pointeurs
    if(tableau==NULL)//si erreur d'allocation
    {
        free(tableau);
        fprintf(stderr, "Erreur de creation du tableau");
        exit(EXIT_FAILURE);//quitter le programme
    }
    for(i=0; i<(dimension1); i++)
    {
        tableau[i]=malloc(dimension2*sizeof(**tableau));//on alloue  des tableaux de taille M
        if(tableau[i]==NULL)//si erreur d'allocation
        {
            for(i=i-1; i>=0; i--) //on parcourt en sens inverse pour liberer ce qui a deja ete alloué
            {
                free(tableau[i]);//liberation de la 2eme dimension
            }
            free(tableau);//liberation de la 1ere dimension
            fprintf(stderr, "Erreur de creation du tableau");
            exit(EXIT_FAILURE);//quitter le programme
        }
    }
    return tableau;
}
/**********************/
int **FonctionLiberation2D(int **Tableau, int dimension1)//libere dynamiquement un tableau a deux dimensions
{
    int i;
 
    for(i=0; i<dimension1; i++)
    {
        free(Tableau[i]);//liberation de la 2eme dimension}
    }
    free(Tableau);//liberation de la 1ere dimension
    Tableau=NULL;
    return Tableau;
}
/**********************/
int main(void)
{
    int i,j;
    int dimension1=2;
    int dimension2=3;
    int dimension3=4;
 
    int Largeur = 6;//Affiche 1 colonne en plus
 
    int HauteurTI = dimension1;
    int **TableauInit=FonctionAllocation2D(HauteurTI,Largeur);
 
    int HauteurTF = dimension2;
    int **TableauFinal=FonctionAllocation2D(HauteurTF,Largeur);
 
    for (i=0; i<HauteurTI; i++)//remplissage du TableauInit
    {
        for (j=0; j<Largeur ; j++)
        {
            TableauInit[i][j]=i+j;
        }
    }
    for (i=0; i<HauteurTF; i++)//remplissage du TableauFinal
    {
        for (j=0; j< Largeur; j++)
        {
            TableauFinal[i][j]=i+j;
        }
    }
    printf("Affichage du TableauInit \n");
    AfficheTableau(TableauInit, HauteurTI, Largeur);//affichage sur la console et dans le fichier
    printf("Affichage du TableauFinal \n");
    AfficheTableau(TableauFinal, HauteurTF, Largeur);//affichage sur la console et dans le fichier
 
    TableauInit=FonctionLiberation2D(TableauInit,HauteurTI);//on libere le tableau initial
    TableauInit=FonctionAllocation2D(HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
 
    for(i=0; i<HauteurTF; i++)              //copie du tableau final dans le tableau initial
    {
        for(j=0; j< Largeur ; j++)
            TableauInit[i][j]=TableauFinal[i][j];
    }
 
    TableauFinal=FonctionLiberation2D(TableauFinal,HauteurTF);//on libere le tableau initial
    HauteurTI=HauteurTF;
    HauteurTF=dimension3;
 
    TableauFinal=FonctionAllocation2D(HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
 
    printf("Affichage du TableauInit avec dimensions modifiees (=ancien TableauFinal) \n");
    AfficheTableau(TableauInit, HauteurTI, Largeur);//affichage sur la console et dans le fichier
 
    TableauInit=FonctionLiberation2D(TableauInit,HauteurTI);
    printf("fermeture du tableau ok \n");
    TableauFinal=FonctionLiberation2D(TableauFinal,HauteurTF);
    printf("fermeture du tableau ok \n");
 
 
    system("pause");
    return 0;
}

version2 qui plante

Code:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#include <stdio.h>
#include <stdlib.h>
 
void AfficheTableau(int **Tableau, int N,int M)
{
    int i, j;
 
    for(i=0; i<N; i++)//affiche tableau
    {
        for(j=0; j<M; j++)
            printf("(%d)",Tableau[i][j]);
        printf("\n");
    }
    printf("\n");
    printf("\n");
}
 
/**********************/
int **FonctionAllocation2D(int dimension1, int dimension2)//alloue dynamiquement un tableau a deux dimensions
{
    int i;
    int **tableau;
 
    tableau=malloc((dimension1)*sizeof(*tableau));//on alloue  N pointeurs
    if(tableau==NULL)//si erreur d'allocation
    {
        free(tableau);
        fprintf(stderr, "Erreur de creation du tableau");
        exit(EXIT_FAILURE);//quitter le programme
    }
    for(i=0; i<(dimension1); i++)
    {
        tableau[i]=malloc(dimension2*sizeof(**tableau));//on alloue  des tableaux de taille M
        if(tableau[i]==NULL)//si erreur d'allocation
        {
            for(i=i-1; i>=0; i--) //on parcourt en sens inverse pour liberer ce qui a deja ete alloué
            {
                free(tableau[i]);//liberation de la 2eme dimension
            }
            free(tableau);//liberation de la 1ere dimension
            fprintf(stderr, "Erreur de creation du tableau");
            exit(EXIT_FAILURE);//quitter le programme
        }
    }
    return tableau;
}
/**********************/
int **FonctionLiberation2D(int **Tableau, int dimension1)//libere dynamiquement un tableau a deux dimensions
{
    int i;
 
    for(i=0; i<dimension1; i++)
    {
        free(Tableau[i]);//liberation de la 2eme dimension}
    }
    free(Tableau);//liberation de la 1ere dimension
    Tableau=NULL;
    return Tableau;
}
/**********************/
 
 
void PreparationNouveauxTableaux(int **TableauInit, int *HauteurTI, int Largeur, int **TableauFinal,int *HauteurTF,int dimension3)
{
    int i,j;
    TableauInit=FonctionLiberation2D(TableauInit,*HauteurTI);//on libere le tableau initial
    TableauInit=FonctionAllocation2D(*HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
 
    for(i=0; i<*HauteurTF; i++)              //copie du tableau final dans le tableau initial
    {
        for(j=0; j< Largeur ; j++)
            TableauInit[i][j]=TableauFinal[i][j];
    }
 
    TableauFinal=FonctionLiberation2D(TableauFinal,*HauteurTF);//on libere le tableau initial
    *HauteurTI=*HauteurTF;
    *HauteurTF=dimension3;
 
    TableauFinal=FonctionAllocation2D(*HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
}
 
 
/**********************/
int main(void)
{
    int i,j;
    int dimension1=2;
    int dimension2=3;
    int dimension3=4;
 
    int Largeur = 6;//Affiche 1 colonne en plus
 
    int HauteurTI = dimension1;
    int **TableauInit=FonctionAllocation2D(HauteurTI,Largeur);
 
    int HauteurTF = dimension2;
    int **TableauFinal=FonctionAllocation2D(HauteurTF,Largeur);
 
    for (i=0; i<HauteurTI; i++)//remplissage du TableauInit
    {
        for (j=0; j<Largeur ; j++)
        {
            TableauInit[i][j]=i+j;
        }
    }
    for (i=0; i<HauteurTF; i++)//remplissage du TableauFinal
    {
        for (j=0; j< Largeur; j++)
        {
            TableauFinal[i][j]=i+j;
        }
    }
    printf("Affichage du TableauInit \n");
    AfficheTableau(TableauInit, HauteurTI, Largeur);//affichage sur la console et dans le fichier
    printf("Affichage du TableauFinal \n");
    AfficheTableau(TableauFinal, HauteurTF, Largeur);//affichage sur la console et dans le fichier
 
    PreparationNouveauxTableaux(TableauInit, &HauteurTI, Largeur, TableauFinal,&HauteurTF,dimension3);
 
        /*
          TableauInit=FonctionLiberation2D(TableauInit,HauteurTI);//on libere le tableau initial
          TableauInit=FonctionAllocation2D(HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
 
          for(i=0; i<HauteurTF; i++)              //copie du tableau final dans le tableau initial
          {
              for(j=0; j< Largeur ; j++)
                  TableauInit[i][j]=TableauFinal[i][j];
          }
 
          TableauFinal=FonctionLiberation2D(TableauFinal,HauteurTF);//on libere le tableau initial
          HauteurTI=HauteurTF;
          HauteurTF=dimension3;
 
          TableauFinal=FonctionAllocation2D(HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
        */
        printf("Affichage du TableauInit avec dimensions modifiees (=ancien TableauFinal) \n");
        AfficheTableau(TableauInit, HauteurTI, Largeur);//affichage sur la console et dans le fichier
 
        TableauInit=FonctionLiberation2D(TableauInit,HauteurTI);
        printf("fermeture du tableau ok \n");
        TableauFinal=FonctionLiberation2D(TableauFinal,HauteurTF);
        printf("fermeture du tableau ok \n");
 
 
        system("pause");
        return 0;
    }

J'ai juste défini une fonction PreparationNouveauxTableaux qui recevait les dimensions sous forme de pointeurs et plus sous forme d'entiers.
Il semblerait y avoir un problème au niveau de la déclaration du TableauInitial et de sa copie.

Je vous serais très reconnaissant de l'aide que vous pourriez m'apporter

Cordialement
Ludo

Bonjour
Citation:
Envoyé par chamludo
J'ai voulu transférer une partie du main dans une fonction, et là, le programme compile, mais plante.
version2 qui plante
Code:

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 void PreparationNouveauxTableaux(int **TableauInit, int *HauteurTI, int Largeur, int **TableauFinal,int *HauteurTF,int dimension3) { int i,j; TableauInit=FonctionLiberation2D(TableauInit,*HauteurTI);//on libere le tableau initial TableauInit=FonctionAllocation2D(*HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final for(i=0; i<*HauteurTF; i++) //copie du tableau final dans le tableau initial { for(j=0; j< Largeur ; j++) TableauInit[i][j]=TableauFinal[i][j]; } TableauFinal=FonctionLiberation2D(TableauFinal,*HauteurTF);//on libere le tableau initial *HauteurTI=*HauteurTF; *HauteurTF=dimension3; TableauFinal=FonctionAllocation2D(*HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final } /**********************/ int main(void) { ... PreparationNouveauxTableaux(TableauInit, &HauteurTI, Largeur, TableauFinal,&HauteurTF,dimension3); ... }
Il semblerait y avoir un problème au niveau de la déclaration du TableauInitial et de sa copie.
Normal. Tu déportes une modification d'une variable dans une fonction. Tu dois donc passer l'adresse de la variable à la fonction.

Imaginons que j'iintialise une variable avec 123

Exemple: Initialisation dans le main
Code:

1 2 3 4 int main() { int var; var=123; }
Maintenant je veux déporter l'initialisation dans une sous-fonction. Or une fonction ne peut pas modifier une variable qu'elle ne possède pas. Pour cela, il lui faut recevoir l'adresse de la variable

Exemple2: Initialisation dans une sous-fonction
Code:

1 2 3 4 5 6 7 void init(int *var) { (*var)=123; } int main() { int var; init(&var); }
C'est pareil pour ton "TableauInit". Tant que tu le remplis dans le main() ça va mais si tu veux le faire remplir par une fonction il faut que la fonction reçoive son adresse.

Maintenant le truc que je trouve bizarre c'est que ta fonction "liberation" met le tableau libéré à NULL puis renvoie cette valeur => elle renvoie donc NULL. Autant alors renvoyer directement NULL.
Toutefois une fonction qui ne fait que renvoyer NULL a alors peu de plus value. Autant alors ne rien lui faire renvoyer.
Accessoirement on ne quitte pas une fonction par exit().

Et puis aère un peu quoi !!! Ca ne te coûtera pas plus cher de remplacer if(tableau==NULL) par if (tableau == NULL) !!!

Sinon j'aime bien que tu prennes soin de vérifier l'allocation et surtout de libérer ce qui a été alloué si ça plante. Mais c'est malheureusement peu optimisé. Si tu veux bien, je te propose de réécrire la fonction Allocation2D ainsi
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 int **FonctionAllocation2D(int dimension1, int dimension2) { int i; int **tableau; tableau=calloc(dimension1, sizeof(*tableau)); // on alloue N pointeurs tous à 0 if (tableau == NULL) goto erreur_alloc; for (i=0; i < dimension1; i++) { tableau[i]=malloc(dimension2 * sizeof(**tableau)); // on alloue des tableaux de taille M if (tableau[i] == NULL) goto erreur_alloc; } return tableau; erreur_alloc; // libération de tout ce qui a été alloué for(i=0; i < dimension1; i++) free(tableau[i]); // free(NULL) est autorisé free(tableau); // free(NULL) est autorisé fprintf(stderr, "Erreur de creation du tableau"); return NULL; }
Citation:

Envoyé par chamludo

J'ai juste défini une fonction PreparationNouveauxTableaux qui recevait les dimensions sous forme de pointeurs et plus sous forme d'entiers.

Pourquoi faire ??? Le pointeur c'est bien mais c'est pas non plus le truc à mettre de partout. Parce que imaginons une fonction carre() définie ainsi: int carre(int n) { return n*n }. Je peux très bien la transformer ainsi: int carre(int *n) { return (*n) * (*n) } ça fonctionnera sauf que je peux plus écrire printf("%d\n", carre(5)).
On met un pointeur quand
on veut que la fonction modifie la variable dont on lui passe l'adresse
on veut lui passer une structure (une fonction recevant toujours une copie de ce qu'on lui passe, mieux vaut qu'elle recopie l'adresse d'un truc potentiellementtrès gros plutôt qu'elle recopie tout le truc)

21/10/2019, 19h43
chamludo

Merci d'avoir pris le temps de m'avoir donné des conseils.

Concernant les goto, j'avais lu à plusieurs endroits qu'il était déconseillés de les utiliser. Je pensais plutôt faire quelque chose comme

Code:

1
2
3
4
5
6
7
8
9
10
11
 
int erreur =0;
...
decaration du tableau
si tableau==NULL alors erreur=1
...
si ... alors erreur =2
...
switch (erreur)
case 1:...
case 2 :...

.

Pour le passage des tableaux en adresse, je viens de trouver une solution qui semble fonctionner. Voici mon code modifié.

Code:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
void PreparationNouveauxTableaux(int ***TableauInit, int *HauteurTI, int Largeur, int ***TableauFinal,int *HauteurTF,int dimension3)
{
    int i,j;
 
    *TableauInit=FonctionLiberation2D(*TableauInit,*HauteurTI);//on libere le tableau initial
    *TableauInit=FonctionAllocation2D(*HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
 
    for(i=0; i<*HauteurTF; i++)              //copie du tableau final dans le tableau initial
    {
        for(j=0; j< Largeur ; j++)
            (*TableauInit)[i][j]=(*TableauFinal)[i][j];
    }
 
    *TableauFinal=FonctionLiberation2D(*TableauFinal,*HauteurTF);//on libere le tableau initial
    *HauteurTI=*HauteurTF;
    *HauteurTF=dimension3;
 
    *TableauFinal=FonctionAllocation2D(*HauteurTF,Largeur);//on crée un nouveau tableau initial avec les dimensions du tableau final
}
 
/**********************/
int main(void)
{
    int i,j;
    int dimension1=2;
    int dimension2=3;
    int dimension3=4;
 
    int Largeur = 6;//Affiche 1 colonne en plus
 
    int HauteurTI = dimension1;
    int **TableauInit=FonctionAllocation2D(HauteurTI,Largeur);
 
    int HauteurTF = dimension2;
    int **TableauFinal=FonctionAllocation2D(HauteurTF,Largeur);
 
    for (i=0; i<HauteurTI; i++)//remplissage du TableauInit
    {
        for (j=0; j<Largeur ; j++)
        {
            TableauInit[i][j]=i+j;
        }
    }
    for (i=0; i<HauteurTF; i++)//remplissage du TableauFinal
    {
        for (j=0; j< Largeur; j++)
        {
            TableauFinal[i][j]=i+j;
        }
    }
    printf("Affichage du TableauInit \n");
    AfficheTableau(TableauInit, HauteurTI, Largeur);//affichage sur la console et dans le fichier
    printf("Affichage du TableauFinal \n");
    AfficheTableau(TableauFinal, HauteurTF, Largeur);//affichage sur la console et dans le fichier
 
    PreparationNouveauxTableaux(&TableauInit, &HauteurTI, Largeur, &TableauFinal,&HauteurTF,dimension3);
 
        printf("Affichage du TableauInit avec dimensions modifiees (=ancien TableauFinal) \n");
        AfficheTableau(TableauInit, HauteurTI, Largeur);//affichage sur la console et dans le fichier
 
        TableauInit=FonctionLiberation2D(TableauInit,HauteurTI);
        printf("fermeture du tableau ok \n");
        TableauFinal=FonctionLiberation2D(TableauFinal,HauteurTF);
        printf("fermeture du tableau ok \n");
 
 
        system("pause");
        return 0;
    }

21/10/2019, 20h59
Sve@r

Citation:

Envoyé par chamludo

Concernant les goto, j'avais lu à plusieurs endroits qu'il était déconseillés de les utiliser

C'est comme tout outil, c'est déconséillé de les utiliser "mal" ou en "non adéquation". Remplacer une boucle par un goto (comme en basic) c'est déconseillé. Mettre 15 goto à suivre comme des spaghettis c'est déconseillé. Mais créer une zone dédiée au nettoyage de tout ce qui a été alloué en amont ça ne l'est pas.
En fait tout est question de "lisibilité" du code.
21/10/2019, 21h11
chamludo

Merci beaucoup.
Je mets le sujet en résolu.