Comment retourner un tableau en utilisant des structures

**aitlhaj1** · 13/04/2019, 19h58

Bonjour à tout le monde
j'ai un problème à résoudre mais je j'ai trouvé devant moi quelques obstacles.
J'ai essayé de faire un programme en C qui permet de gérer les nom, les notes et leurs moyennes en utilisant une structure et des fonctions.
Je vous donne ma réponse.
et merci pour votre aide.

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
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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
char nom[15];
char prenom[15];
int identifiat;
float note[6];
float moyenne;
}Etudiant;
int i,j;
// fonction et procedure
 
void saisie(Etudiant *E,int nbE){
  for(i=0;i<nbE;i++){
    printf("\n\t\t************ L'information de l'etudiant %d\n",i+1);
    printf("\n donnenr le nome :");
    scanf("%s",E[i].nom);
    printf("\n donnenr le prenome :");
    scanf("%s",E[i].prenom);
    printf("\n donnenr CNE  :");
    scanf("%d",&E[i].identifiat);
    for(j=0;j<6;j++){
        printf("donner la note du module %d:",j+1);
        scanf("%f",&E[i].note[j]);
    }
 
   }
 
 
}
void affiche(Etudiant *E,int nbE){
    printf("\n***************************************************************\n");
    printf("Nom\tprenom\tNote1\tNote2\tNote3\tNote1\tNote2\tNote3\tMoyen\n");
  for(i=0;i<nbE;i++){
 
     printf("\n%s\t%s\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f",E[i].nom, E[i].prenom, E[i].note[0], E[i].note[1], E[i].note[2], E[i].note[3], E[i].note[4], E[i].note[5], calculMoyen(E,nbE));
 
     printf(" \nla moyenne des moyennes de %d Etudiant  est :%.2f\n",nbE,moyClasse(E,nbE));
     printf(" \nle nombre d'etudiants ayant la moyenne superieure a 10 est :%d\n",etudiantSup(E,nbE));
     printf(" \nle nombre d'etudiants ayant la moyenne inferieure a 10 est :%d\n",etudiantInf(E,nbE));
     printf("\n***************************************************************\n");
 
 
  }
  return 0;
}
 
float calculMoyen(Etudiant *E,int nbE){
    float somme;
for(i=0;i<nbE;i++){
    somme=0.0;
    for(j=0;j<6;j++){
 
        somme+=E[i].note[j];
 
    }
     E[i].moyenne=somme/2;
 
   }
 
   return E[i].moyenne;
}
int etudiantSup(Etudiant *E,int nbE){
    int nbSup=0;
 
for(i=0;i<nbE;i++){
 
    if(calculMoyen(E,nbE)>=10.0){
        nbSup++;
 
    }
 
}
  return nbSup;
}
int etudiantInf(Etudiant *E,int nbE){
    int nbInf=0;
 
for(i=0;i<nbE;i++){
 
    if(calculMoyen(E,nbE)<10.0){
        nbInf++;
 
    }
 
}
  return nbInf;
}
float moyClasse(Etudiant *E,int nbE){
float moyDemoy;
float somme=0.0;
 for(i=0;i<nbE;i++){
    somme+=calculMoyen(E,nbE);
 }
 moyDemoy=somme/nbE;
 return moyDemoy;
}
 
int main()
{
    Etudiant E[20];
    int nbE;
 
 
printf("donner le nombre d'etudiant: ");
scanf("%d",&nbE);
saisie(E,nbE);
system("cls");
calculMoyen(E,nbE);
etudiantSup(E,nbE);
etudiantInf(E,nbE);
affiche(E,nbE);
 
 
 
    return 0;
}

**Bousk** · 13/04/2019, 21h25

Bonjour,

quel est le problème ?
Retourner un tableau ? En C il va falloir retourner un truc alloué via malloc, et c'est l'appelant qui aura la responsabilité de le libérer via free.
Ou bien tu peux passer en paramètre de la mémoire déjà allouée et que la fonction ne fera que remplir.

**Sve@r** · 13/04/2019, 21h59

Bonjour

Le C ne permet pas de retourner un tableau. Pour la simple raison que lorsqu'une fonction retourne une variable, elle ne retourne en réalité que la valeur de la variable tandis que la variable (locale à la fonction) est libérée et donc disparait lorsque la fonction se termine. Donc une valeur retournée ça peut passer, tout un tableau ça ne passe pas.
C'est aussi la même raison qui fait que retourner l'adresse d'une variable est source de bug puisque l'appelant récupère l'adresse d'un truc qui a été détruit.

2 solutions de qualité pour qu'une fonction puisse modifier un tableau "extérieur"

la fonction reçoit le tableau de l'appelant et peut alors le remplir => ce n'est donc pas un tableau local à la fonction et donc qui ne disparait pas quand la fonction se termine
la fonction alloue une zone d'octets via malloc. Cette allocation se fait dans une zone mémoire globale au programme appelée "le tas". La zone n'est donc pas libérée lorsque la fonction se termine. La zone se comporte comme un tableau et donc peut y être assimilée. Ensuite la fonction peut retourner l'adresse de cette zone (une simple valeur) à son appelant qui a alors lui aussi accès à la zone (au tableau). Il faudra tout de même penser à libérer cette zone à un moment ou un autre => free()

Il existe une 3° solution: définir le tableau en global. Mais cette solution n'est pas une solution de qualité.

**Matt_Houston** · 13/04/2019, 22h41

Tu peux passer un tableau par valeur s'il est membre d'un objet de classe struct en passant ledit objet.

**aitlhaj1** · 13/04/2019, 22h52

Bonjour
Merci de me donner un exemple pour mieux comprendre.
une structure (char nom,float facture[2])
une fonction qui calcule la somme
une fonction d'affichage.

**Sve@r** · 13/04/2019, 23h12

Envoyé par aitlhaj1

Merci de me donner un exemple pour mieux comprendre.

Code c :

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
#include <stdio.h>
#include <string.h>
 
typedef struct {
	char tab[10];
} t_truc;
 
t_truc fonction() {
	t_truc machin;
	strcpy(machin.tab, "Hello");
	return machin;
}
 
int main() {
	t_truc truc;
	truc=fonction();
	printf("%s\n", truc.tab);
}

C'est vrai que c'est une solution. Solution que je n'apprécie pas forcément (l'ensemble de la structure est recopiée => si la structure fait 500 000 octets et que la fonction est appelée 400 000 fois...)
mais c'est aussi une possibilité...

**aitlhaj1** · 13/04/2019, 23h32

merci pour votre réponse.je dois essayé de resoudre mon prob.

**darkwall_37** · 14/04/2019, 16h34

Salut,

Chacun sa façon de faire mais tu si tu arrives à lire ton code de la façon dont c'est indenté tant mieux pour toi mais à titre personnel je trouve ça parfaitement illisible.
Je te propose une structure classe_t qui contient une structure etudiant_t de n etudiants.
Dans le main, concrètement, il te reste à faire une fonction de saisie qui utilise la fonction etudiant_ajouter pour remplir ta structure classe_t et donc etudiant_t implicitement.

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
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct
{
    char *nom;
    char *prenom;
    unsigned int id;
    float note[6];
    float moyenne;
}etudiant_t;
 
typedef struct
{
    etudiant_t *e;
    size_t nb_etudiant;
}classe_t;
 
etudiant_t *etudiant_create_struct( size_t nb_etudiant )
{
    etudiant_t *st = NULL;
    if ( (st = malloc( nb_etudiant*sizeof( *st ) )) )
    {
        for( size_t i=0 ; i<nb_etudiant ; i++ )
        {
            st[i].nom = NULL;
            st[i].prenom = NULL;
            st[i].id = 0;
            st[i].moyenne = 0.;
            for ( size_t j=0 ; j<6 ; j++ )
                st[i].note[j]=0.;
        }
    }
    return st;
}
 
void etudiant_destroy_struct( etudiant_t *st, size_t nb_etudiant )
{
    if ( st )
    {
        for ( size_t i=0 ; i<nb_etudiant ; i++ )
        {
            if ( st[i].nom )
                free(st[i].nom);
 
            if ( st[i].prenom )
                free(st[i].prenom);
        }
        free(st);
    }
}
 
classe_t *classe_create_struct( size_t nb_etudiant )
{
    classe_t *st = NULL;
    if ( ( st = malloc( sizeof( *st ) ) ) )
    {
         st->e = NULL;
         if ( (st->e = etudiant_create_struct( nb_etudiant ) ) )
            st->nb_etudiant = nb_etudiant;
    }
    return st;
}
 
void classe_destroy_stuct( classe_t *st )
{
    if ( st )
    {
        if ( st->e )
            etudiant_destroy_struct( st->e, st->nb_etudiant );
 
        free(st);
    }
}
 
void display_etudiant( etudiant_t *e )
{
    if ( e )
    {
        printf("\n----------------------------------------");
        if (e->nom)
            printf("\n\t Nom : %s", e->nom);
        else printf("\n\t Nom : Aucun nom renseigne ");
 
        if (e->prenom)
            printf("\n\t Prenom : %s", e->prenom);
        else printf("\n\t Prenom : Aucun prenom renseigne ");
 
        if ( e->id != 0 )
            printf("\n\t id: %u", e->id);
        else printf("\n\t id : Aucune valeur renseignee ");
 
        printf("\n\t Moyenne : %2.2f\n", e->moyenne);
    }
}
 
float moyenne( float *p, size_t sz )
{
    float moyenne =  0.;
    if (p)
    {
        for ( size_t i=0 ; i<sz ; i++ )
            moyenne += p[i]/(1.*sz);
    }
    return moyenne;
}
 
void etudiant_ajouter ( classe_t **c, size_t index, const char *nom, const char* prenom, unsigned int id, float *note )
{
    if ( *c )
    {
        if ( !(*c)->e[index].nom )
        {
            char *p = NULL;
            if ( ( p = malloc( (strlen(nom)+1)*sizeof(*p) ) ) )
            {
                (*c)->e[index].nom = p;
                strcpy( (*c)->e[index].nom, nom );
            }
        }
 
        if ( !(*c)->e[index].prenom )
        {
            char *p = NULL;
            if ( ( p = malloc( (strlen(prenom)+1)*sizeof(*p) ) ) )
            {
                (*c)->e[index].prenom = p;
                strcpy( (*c)->e[index].prenom, prenom );
            }
        }
 
        (*c)->e[index].id = id;
 
        for( size_t i=0 ; i<6 ; i++ )
            (*c)->e[index].note[i] = note[i];
 
        (*c)->e[index].moyenne = moyenne( note, 6 );
    }
}
 
void display_class( classe_t *c )
{
    if ( c )
    {
        for ( size_t i=0 ; i<c->nb_etudiant ; i++ )
            display_etudiant( &c->e[i] );
    }
}
 
int main(void)
{
    //Creation de la structure classe qui contient 15 étudiants
    classe_t *classe = classe_create_struct( 15 );
 
    //Afficher tous les étudiants de la classe parès la création de la structure 
    display_class( classe );
 
    //Ajout d'un étudiant en position 0
    float *note = malloc( 6*sizeof(*note) ); // Création d'un tableau de note fictives pour le test
    note[0]=8., note[1]=9., note[2]=10., note[3]=11., note[4]=12., note[5]=13.;
 
    etudiant_ajouter( &classe, 0, "Bon", "Jean", 1236, note ); // On ajoute l'étudiant Jean Bon ayant pour id 1236
    free(note); // On libère la mémoire allouée pour le tableau de note de l'étudiant en position 0
 
    //Afficher tous les étudiants de la classe
    display_class( classe );
 
    //Destruction de la mémoire utilisée par la structure classe_t
    classe_destroy_stuct( classe );
    return 0;
}

**Sve@r** · 14/04/2019, 17h58

Envoyé par darkwall_37

Je te propose une structure classe_t qui contient une structure etudiant_t de n etudiants.

Pourquoi tes noms et prénom sont des pointeurs ? Faudra les allouer quoi.
Accessoirement pas besoin de les contrôler avant de les "freer". La fonctionfree() accepte de recevoir un NULL en paramètre. Bon évidemment free(NULL) c'est un appel pour rien donc vaut-il mieux appeler pour rien ou tester à chaque coup ça...

**darkwall_37** · 14/04/2019, 18h27

Hello,

Concernant l'utilisation de free, c'est une convention que j'ai choisie d'adopter.
Comme tu le dis bien, je ne sais pas s'il y a une bonne façon de faire. Y'a deux écoles.
Je considère qu'un pointeur NULL ne devrait pas être freed à nouveau.
J'adopte le point de vue conceptuel plus que fonctionnel.

Pourquoi j'utilise des pointeurs ?
Effectivement, on pourrait ne pas en utiliser, mais :
- Pour éviter les sigsev, je préfère allouer et initialiser, on est pas à l'abris de vouloir copier une chaîne plus grande que possible pour une raison X ou Y. Je considère ici que l'utilisateur du programme est "bête".
- On alloue que ce dont on a besoin. Supposons que ce soit une base qui contiendra 100k élèves, ça fait quelques octets de perdus.
- Pour montrer la manipulation des pointeurs. Ça ne fait jamais de mal ^^

Dans le meilleur des mondes, où l’utilisateur sait parfaitement ce qu'il fait, je te rejoints sur la non nécessité d'utiliser les pointeurs.
Après, je ne suis pas développeur professionnel donc je ne préfère pas m'avancer. Je programme/développe pour mon plaisir personnel.
Vous devez probablement avoir de meilleurs références à ce sujet.