Discussion :

[Mornor]

Bonjour à tous,

Voici quelques jours que j'essaye de faire un programme (assez classique) utilisant des structures, des tableaux et donc des mallocs.

Voici mes structures :

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
typedef struct{
    char rue[MAX_CHAR];
    char ville[MAX_CHAR];
    int num;
    int cp;
}T_Adresse;
 
typedef struct
{
    char matricule[MAX_CHAR];
    char nom[MAX_CHAR];
    char prenom[MAX_CHAR];
    double tabCotes[5];
    double moyennePourcentage;
    T_Adresse adr;
}T_Etudiant;
 
typedef struct{
    char nomCours[MAX_CHAR];
    int ponderation;
}T_Cours;
 
typedef struct{
    int nbEtu;
    T_Etudiant * classe;
}T_Classe;
 
// Definition d'une annee/section (1TI)
typedef struct{
    char nomAnneeSection[MAX_CHAR];
    int nbClasses;
    char *nomClasse; // Tableau contenant le nom des cours. (1TM1)
    int nbCoursParEtudiant;
    T_Cours *tabCours;
    T_Classe *tabClasse;
}T_AnneeSection;

Je créer un tableau de T_AnneeSection comme ceci :

Code :

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

T_AnneeSection * tabAnneeSection = NULL; // Ecole (tabAnnneeSection)

Que je passe à la fonction afficherMenuGlobal :

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
void afficherMenuGlobal(T_AnneeSection * tab)
{
    tab = malloc(INCREMENTALLOC * sizeof(T_AnneeSection));
 
    int choix = 0, nbrAnneeSection = 0, i = 0;
 
    printf("1. Charger le tableau d'annee/section.\n");
    printf("2. Creer une annee/section\n\n");
 
    scanf("%d", &choix);
 
    if(choix == 2)
    {
        for(i = 0 ; i < 2 ; i++)
        demanderInfo(tab);
    }
 
 
 
}

Je veux donc créer 1 anneeSection dans le tableau tab.
Grâce à la méthode suivante :

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
 
/*Permet de créer 1 anneeSection */
void demanderInfo(T_AnneeSection * anneeSection)
{
    int i = 0;
 
    printf("Nom (ex : 1TI) : ");
    fflush(stdin);
    gets(anneeSection->nomAnneeSection);
    printf("Nombre de Classes : ");
    fflush(stdin);
    gets(anneeSection->nbClasses);
 
    anneeSection->tabClasse = (T_Classe *)malloc(anneeSection->nbClasses * sizeof(T_Classe));
 
    for(i = 0 ; i < anneeSection->nbClasses ; i++)
    {
        printf("\t Nom de la classe %d (ex : 1TM1) : ", i+1);
        fflush(stdin);
        gets(anneeSection->nomClasse[i]);
    }
 
    printf("Nombre de cours par etudiant : ");
    fflush(stdin);
    scanf("%d", anneeSection->nbCoursParEtudiant);
 
    anneeSection->tabCours = malloc(anneeSection->nbCoursParEtudiant * sizeof(T_Cours));
 
    for(i = 0 ; i < anneeSection->nbCoursParEtudiant ; i++)
    {
        printf("\t Nom du cours %d : ", i+1);
        gets(anneeSection->tabCours[i].nomCours);
        printf("\t Ponderation de ce cours : ");
        scanf("%d", anneeSection->tabCours[i].ponderation);
    }
 
}

Mais il y'a une erreur d’exécution, dès que je demande le nom des classes dans la première boucle for de demanderInfo().

De plus, j'envoie tab dans demanderInfo, et non tab[i], car j'ai une erreur de compilation ... Pourquoi ?

Désolé pour ce long énoncé, mais je ne voyais pas comment expliquer autrement ...

Un énorme merci à ceux qui prendront la peine d'y jeter un coup d'oeil.

Cordialement,

Mornor.

[Franck.H]

Ton code est un peu faut je dirais :

Code :

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

1
2
3
void afficherMenuGlobal(T_AnneeSection * tab)
{
    tab = malloc(INCREMENTALLOC * sizeof(T_AnneeSection));

Ici tu prend l'argument passé en paramètre à ta fonction afficherMenuGlobal or tu ne peux pas faire ainsi. Dans l'idéal et pour faire propre, ta fonction se doit uniquement d'afficher d'où son nom, créé à côté une fonction propre à l'initialisation de tes tableaux (allocation, remplissage et destruction), je te montre la bonne marche à suivre :

Code :

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

T_AnneeSection * creerTabAnneeSection (void)

Ceci pour la signature de la fonction. Tu peux éventuellement mettre un paramètre de taille pour l'allocation. Ici tu as donc une fonction qui retourne un T_AnneeSection. Tu peux toujours faire par le biais du paramètre comme tu faisait avant mais il faut faire un peu plus de gymnastique dans ce cas comme par exemple :

Code :

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

1
2
3
void afficherMenuGlobal (T_AnneeSection ** tab)
{
    *tab = malloc(INCREMENTALLOC * sizeof(*tab));

mais il faudra alors que tu passe non pas le pointeur lors de l'appel de la fonction mais l'adresse:

Code :

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

affichierMenuGlobal (&tab);

Ca marche aussi mais c'est pas trop dans les bonnes pratiques dans ce genre de cas par contre, pour une fonction de libération pourquoi pas.

Pour l'allocation tu y est presque :

Code :

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

tab = malloc(INCREMENTALLOC * sizeof(* tab));

ou

Code :

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

tab = malloc(INCREMENTALLOC * sizeof(T_AnneeSection *));

je préfère la première solution car si tu change le nom de ta structure tu n'auras aucune modification à apporter au code à ce niveau.
Je n'ai pas tout lu en détails mais j'ai remarqué une autre petite erreur, pas dramatique et sans conséquence mais pour simplifier la lecture et la compréhension au lieu de faire :

Code :

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

anneeSection->tabClasse = (T_Classe *)malloc(anneeSection->nbClasses * sizeof(T_Classe));

Ne fait pas de cast, ton membre tabClasse étant de toute manière de type T_Classe inutile de le caster Ce qui nous donne avec quelques modifications :

Code :

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

anneeSection->tabClasse = malloc(anneeSection->nbClasses * sizeof(T_Classe *));

Pour info également, test toujours le retour de tes malloc pour t'assurer que l'allocation à bien été réalisée :

Code :

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

1
2
3
4
5
6
tab = malloc(INCREMENTALLOC * sizeof(* tab));
 
if (tab != NULL)
{
   /* Allocation reussie, suite du code ici... */
}

Par soucis de sécurité du code pour éviter des plantages éventuels et devoir chercher partout, pense toujours à tester tes arguments surtout si ce sont des pointeurs comme :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void demanderInfo (T_AnneeSection * anneeSection)
{
   if (anneeSection != NULL)
   {
      /* Ton code ici... */
   }
   else
   {
      fprintf (stderr, "Ton message d'erreur ici...\n");
   }
}

Surtout que plus bas tu fais l'allocation de anneeSection->nbClasses et c'est pour cela à mon avis que tu ne trouvais pas ton erreur, ton tableau vaux NULL par rapport à ta manière de faire alors que si tu avais fait les test partout et en mettant des messages d'erreur tu aurais su immédiatement où se trouvais l'erreur, du moins en partie

[Mornor]

Waoow !!

Ca c'est de la réponse !

Un énorme merci pour tous ces conseils ! Je les ai appliqués minutieusement et tout fonctionne à merveille !

Le C demande quand même une sacrée gymnastique mentale ...

Une dernière question cependant.
Je voudrais écrire ces années section, stockées dans un tableau de la manière suivante :

Code :

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

    T_AnneeSection * tabAnneeSection;

Pour rappel, une Annee/section est constituée de la sorte :

Code :

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

1
2
3
4
5
6
7
8
9
// Definition d'une annee/section (1TI)
typedef struct{
    char nomAnneeSection[MAX_CHAR];
    int nbClasses;
    char **nomClasse; // Tableau contenant le nom des classes. (1TM1)
    int nbCoursParEtudiant;
    T_Cours *tabCours;
    T_Classe *tabClasse; // Tableau de classe, exemple : 1TM1
}T_AnneeSection;

Et ma méthode de sauvegarde : (nbr est le nombre d'annee/section présentes en mémoire centrale) :

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
void sauverFichierParametrage(T_AnneeSection * tab, int nbr)
{
    FILE *f = NULL;
    int i = 0, j = 0, k = 0;
 
    f = fopen(FICHIER_PARAMETRAGE, "w+");
    if(f == NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", FICHIER_PARAMETRAGE);
        exit(0);
    }
 
    fprintf(f, "%d\n", nbr); // Ecriture du nombre total d'années/sections.
 
    for(i = 0 ; i < nbr ; i++)
    {
        fprintf(f, "Section %d : \n", i+1);
        fprintf(f, "Nom : %s\n", tab[i].nomAnneeSection);
        fprintf(f, "Nombre de classe : %d\n", tab[i].nbClasses);
        for(j = 0 ; j < tab[i].nbClasses ; j++)
            fprintf(f, "Classe %d : %s\n", j+1, tab[i].nomClasse);
        fprintf(f, "Nombre de cours par etudiants : %d\n", tab[i].nbCoursParEtudiant);
        for(k = 0 ; k < tab[i].nbCoursParEtudiant ; k++)
        {
            fprintf(f, "Nom du cours %d : %s\n", k+1, tab[i].tabCours[k].nomCours);
            fprintf(f, "Ponderation de ce cours : %d\n", tab[i].tabCours[k].ponderation);
        }
 
        fprintf(f, "\n");
    }
 
    fclose(f);
}

Ce code me semble juste, mais je ne sais pas comment accéder au champ char **nomClasse de T_Aneee/section, afin d'écrire le nombre de classe présente dans le tableau tab.

Aurait-tu une solution, voire un indice à me donner ?

Grand merci !!

[Franck.H]

Waoow !!

Ca c'est de la réponse !

Un énorme merci pour tous ces conseils ! Je les ai appliqués minutieusement et tout fonctionne à merveille !

C'est déjà une bonne chose

Le C demande quand même une sacrée gymnastique mentale ...

Oui entre autre mais surtout de la réflexion et de la rigueur.

Ce code me semble juste, mais je ne sais pas comment accéder au champ char **nomClasse de T_Aneee/section, afin d'écrire le nombre de classe présente dans le tableau tab.
Aurait-tu une solution, voire un indice à me donner ?

En toute logique ce serait:

Code :

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

fprintf(f, "Classe %d : %s\n", j+1, tab[i].nomClasse[j]);

[Mornor]

Merci de la réponse !

Hélas, cela ne fonctionne pas ...

Je pense que le problème vient en fait de la méthode qui demande le nom des classes.

J'ai modifié mon type T_Annee/section pour avoir un tableau de tableau de caractères pour enregistrer les nom des différentes classes (MAX_CHAR vaut 51):

Code :

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

1
2
3
4
5
6
7
8
9
10
 
// Definition d'une annee/section (1TI)
typedef struct{
    char nomAnneeSection[MAX_CHAR];
    int nbClasses;
    char *nomClasse[MAX_CHAR]; // Tableau contenant le nom des classes. (1TM1)
    int nbCoursParEtudiant;
    T_Cours *tabCours;
    T_Classe *tabClasse; // Tableau de classe, exemple : 1TM1
}T_AnneeSection;

J'envoie ensuite ce tableau dans une méthode selon la syntaxe suivante :

Code :

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

1
2
for(i = 0 ; i < nbrAnneeSection ; i++)
            tab[i] = demanderInfo(tab[i]);

Et dans cette méthode, je récupère le nom de toutes les classes :

Code :

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

1
2
3
4
5
6
7
8
9
10
T_AnneeSection demanderInfo(T_AnneeSection anneeSection)
{
 for(i = 0 ; i < anneeSection.nbClasses ; i++)
        {
                printf("\t Nom de la classe %d (ex : 1TM1) : ", i+1);
                fflush(stdin);
                gets(&anneeSection.nomClasse[i]);
        }
return anneSection; 
}

Que j'enregistre ensuite dans le fichier de la manière suivante :

Code :

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

1
2
3
4
5
6
7
8
 
void sauverFichierParametrage(T_AnneeSection * tab, int nbr)
{
for(j = 0 ; j < tab[i].nbClasses ; j++)
        {
            fprintf(f, "Classe %d : %s\n", j+1, tab[i].nomClasse[j]);
        }
}

Problème, le nomClasse[j] ne passe pas lors de l'éxecution.

J'ai l'impression que je n'ai pas fait de malloc, afin d'allouer une certaine taille au tableau contenant le nom des classes.

Mais je ne sais pas comme faire un malloc sur ce type, j'ai essayé :

Code :

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

1
2
 
anneeSection.nomClasse = malloc(anneeSection.nbClasse * sizeof(???)

Je ne peux pas "mallocer" un tableau de char, vu qu'une chaine est composée de maximum 51 char (MAX_CHAR)

Comment puis-je résoudre ce problème ?

Énorme merci à vous !

[Sve@r]

Merci de la réponse !

Hélas, cela ne fonctionne pas ...

Je pense que le problème vient en fait de la méthode qui demande le nom des classes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
T_AnneeSection demanderInfo(T_AnneeSection anneeSection)
{
for(i = 0 ; i < anneeSection.nbClasses ; i++)
        {
            /*Malloc de chaque tableau de char. (16 lettres maximum) */
            anneeSection.nomClasse = malloc(anneeSection.nbClasses * sizeof(char[16]));
            printf("\t Nom de la classe %d (ex : 1TM1) : ", i+1);
            fflush(stdin);
            gets(&anneeSection.nomClasse[i]);
        }
 
return anneeSection; 
 
}

le gets(&anneeSection.nomClasse[i]) est faut.
Je veux faire un tableaux de "String", donc un tableau de tableau de char n'est-ce pas ?
Cela s'écrit pourtant bien de cette maniere :
char **nomClasse.

Salut
Déjà il est préférable de passer l'adresse d'une structure à une fonction plutôt que la structure elle-même. Parce qu'un paramètre étant copié et que copier une adresse de 2 octets est plus rapide que copier une structure à 40000 octets. Et pareil pour le return (qui est toutefois un peu inutile vu que c'est idiot de retourner un truc que l'appelant possède déjà sauf si ça permet de distinguer un cas normal d'une erreur...)

De plus le fflush(stdin) est à proscrire. Il signifie "je ne sais pas gérer mon clavier" et en plus n'est pas implémenté de partout (en fait il n'est implémenté que sous Windows).
En revanche fflush(stdout) serait utile vu que le printf() précédent n'a pas de '\n'.

Ensuite effectivement un tableau de string est un char **. Mais dans ce cas, il faudra alors allouer d'abord le tableau pour stocker n noms, puis ensuite pour les n noms allouer chaque nom à 16 caractères.
Ou alors, ce que tu fais, tu décides d'allouer directement n * 16 caractères sur une grosse map. C'est possible mais ensuite c'est à toi de gérer la map. Car chaque nom[x] sera en fait positionné sur la map à la position [x * 16]. Et tu ne feras alors qu'un seul malloc() et non n malloc().

Mais alors il faudra utiliser une fonction capable de gérer une saisie à 16 caractères donc remplacer gets() qui n'a pas de limite (ce qui est d'ailleurs super dangereux) par fgets(). Et dans ce cas, purger le nom saisi du caractère '\n' représentant le <return> que tu appuies pour valider un nom.

Ce qui donnerait alors

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
T_AnneeSection *demanderInfo(T_AnneeSection *anneeSection)
{
     char *pt;
 
     /*Malloc de la map n noms à 16 car. */
    anneeSection->nomClasse = malloc(anneeSection.nbClasses * 16 * sizeof(char));
    if (anneeSection->nomClasse == NULL) return NULL
 
    for(i = 0 ; i < anneeSection->nbClasses ; i++)
    {
        printf("\t Nom de la classe %d (ex : 1TM1) : ", i+1);
        fflush(stdout);
        fgets(&anneeSection->nomClasse[i * 16], 16, stdin);
        if ((pt=strchr(&anneeSection->nomClasse[i * 16], '\n')) != NULL)
             *pt='\0';
    }
 
    printf("Vérification saisie\n")
    for(i = 0 ; i < anneeSection->nbClasses ; i++)
    {
        printf("\t Nom de la classe %d: [%s]\n", i+1,&anneeSection->nomClasse[i * 16]);
    }
 
    return anneeSection; 
}

PS: attention, tu parles de "16" caractères mais j'y ai inclus le '\0'. Si tu parlais de 16 caractères "utiles" il te faut alors en rajouter un 17° pour le '\0'.
Généralement, ce qui est assez usité, c'est utiliser une macro style #define SZ_NOM (16 + 1). Le "+1" signifiant aux autres lecteurs "j'ai bien pensé au \0". Ensuite tu remplaces partout dans ton code le "16" par "SZ_NOM". Ca permet plus tard, si la taille change, de ne faire qu'une seule modif dans le code et recompiler.

[Mornor]

Ouf ... Assez tordu comme signature de méthode !
Je comprend le principe, mais je prérfererai le faire avec plusieurs mallocs, ça me semble plus "compréhensible"

Donc, imaginons que j'ai char **nomClasse comme tableau de "String"

J'ai fait ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 anneeSection.nomClasse = (char **)malloc(anneeSection.nbClasses * sizeof(char*));
 
        for(i = 0 ; i < anneeSection.nbClasses ; i++)
        {
            anneeSection.nomClasse[i] = (char *)malloc(MAX_CHAR * sizeof(char));
            printf("\t Nom de la classe %d (ex : 1TM1) : ", i+1);
            fflush(stdin);
            gets(&anneeSection.nomClasse[i]);
        }

Mais quand je test :

Code :

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

1
2
3
 
 for(i = 0 ; i < anneeSection.nbClasses; i++)
            printf("%s\n", &anneeSection.nomClasse[i]);

Si par exemple classe 1 = c1 et classe 2 = c2
J'ai à l'éxecution : "c1c2 puis c2"

Pourquoi ?

EDIT : Je viens de comprendre, comme j'avais le &, il stokait le bazar à la même adresse.

[Sve@r]

Ouf ... Assez tordu comme signature de méthode !
Je comprend le principe, mais je prérfererai le faire avec plusieurs mallocs, ça me semble plus "compréhensible"

Au niveau codage c'est effectivement plus lisible mais au final, le code compilé est exactement le même.
Pense aussi qu'il te faut vérifier chaque malloc. Et aussi prévoir un cas si un des malloc échoue (purger alors tout ce qui a été alloué et quitter la fonction). Donc effectivement plus "compréhensible" mais aussi plus chiant à gérer...

EDIT : Je viens de comprendre, comme j'avais le &, il stokait le bazar à la même adresse.

Hé oui. anneeSection.nomClasse[i] étant déjà un char*, pas besoin de mettre "&" devant. sinon tu passes à scanf l'adresse de ce char * donc un char **.
Et idem pour printf()...

[Mornor]

Un tout tout grand merci à tous !

Merci de prendre du temps pour expliquer tout cela, c'est vraiment chouette de votre part, vraiment.

Tout fonctionne, enfin

C'est quand même génial de coder !