Discussion :

[ngalla]

Boujour,
je voudrais svp savoir quant est ce qu'on utilise structure, union et enum.
Et si possible les amis, vous me donner un exercice pour voir.
Merci et bientôt.

[30barrett40]

Une structure est une variable personnalisé qui contient plusieurs variables, qui peuvent être de types différents.
Une énumération est une variable personnalisé qui peut prendre une des valeurs préparées.

[Emmanuel Delahaye]

je voudrais svp savoir quant est ce qu'on utilise structure, union et enum.
Et si possible les amis, vous me donner un exercice pour voir.

struct
Typiquement, une structure sert à regrouper des éléments qui peuvent être de types différents, mais que l'on manipule ensemble.

Exemple classique : le répertoire téléphonique.

On utilise une structure qui regroupe les données sous la forme d'un 'enregistrement' constitué de 'champs' :

Code :

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

1
2
3
4
5
6
7
8
 
struct enregistrement
{
   char nom[32];
   char prenom[32];
   char fixe[16];
   char portable[16];
};

Ca permet de créer un tableau de structure,

Code :

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

struct enregistrement fichier[10];

de le parcourir, de le trier, de chercher quelque chose dedans etc.

Ca sert aussi à organiser les données de configuration d'un programme, à la constructions de structures de données évoluées (piles, files, listes etc.), à implémenter les types abstraits de données (ADT ou TAD).

Les applications sont innombrables...

enum
Usage méconnu et pourtant bien pratique. Ca permet de définir une série de valeurs constantes toutes différentes.

enum fruits {pomme, banane, mangue, orange, kiwi};

union
Les applications sont beaucoup plus rares. Associée à une structure et à un 'sélecteur', elles permettent, dans une même structure, de définir des champs de types différents, mais pas 'en même temps'. Selon la valeur du selecteur, il faudra interpréter le champs de telle ou telle façon.

On peut définir un sélecteur avec un enum :

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
 
enum selecteur {A, B, C};
 
struct a
{
   int x;
   char y[10];
};
 
struct b
{
   int xx;
   long yy;
};
 
struct c
{
   char xxx[32];
   double yyy;
   double zzz;
};
 
struct parametres
{
   enum selecteur selecteur;
 
   union
   {
      struct a;
      struct b;
      struct c;
   }
   u;
};
 
fonction (struct parametres *p_parametres)
{
   switch (p_parametres->selecteur)
   {
   case A:
      traitement_a (&p_parametres->u.a);
      break;
 
   case B:
      traitement_b (&p_parametres->u.b);
      break;
 
   case C:
      traitement_c (&p_parametres->u.c);
      break;
 
   default:
      /* erreur */
      ;
   }
}

etc. (non compilé)

[Thierry Chappuis]

Tu te sers d'une structure pour gouper des variables qui sont associées. Par exemple, tu désires dans ton programme représenter un étudient. Cet étudient est décrit par son nom (chaîne de caractères), son prénom (chaîne de caractères), son école (chaîne de caractères) et son âge (unsigned int). Ainsi, on peut écrire le code suivant:

Code :

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

1
2
3
4
5
6
struct Etudient {
    char s_nom[20];
    char s_prenom[20];
    char s_ecole[50];
    unsigned int age;
};

De cette manière, il t'est possible de manipuler un objet de type struct Etudient comme un tout:

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
#include <stdio.h>
#include <stdlib.h>
 
struct Etudient {
    char s_nom[20];
    char s_prenom[20];
    char s_ecole[50];
    unsigned int age;
};
 
int main(void)
{
    struct Etudient moi = 
        {
            "Chappuis",
            "Thierry",
            "Ecole Polytechnique Fédérale de Lausanne",
            29
        };
 
    printf("%s %s, %d ans\n%s\n", moi.s_prenom, moi.s_nom, 
            moi.age, moi.s_ecole);
    return EXIT_SUCCESS;
}

On peut créer des tableaux de struct Etudient afin de répertorier un ensembles d'étudients. On peut passer une variable de type struct Etudient à une fonction. Bref! Une structure est extrêmement pratique lorsqu'il s'agit de manipuler toutes les variables représentant un étudient comme un tout.

En ce qui concerne les énumérations, on s'en sert lorsqu'une variable ne peut prendre qu'un nombre fini de valeurs entières. Exemple:

Code :

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

enum Jours {LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE};

L'écriture ci-dessus est en fait équivalente à:

Code :

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

1
2
enum Jours {LUNDI=0, MARDI=1, MERCREDI=2, JEUDI=3, 
        VENDREDI=4, SAMEDI=5, DIMANCHE=6};

Voici un exemple de programme:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
enum Jours {JOUR_ERROR = -1, LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI,
        SAMEDI, DIMANCHE};
 
int jour2str(char *s_chaine, size_t taille, enum Jours jour);
 
int main(void)
{
    enum Jours today = LUNDI;
    /* La valeur de la valiable today est une constante entière qui vaut 0 (LUNDI) */
    printf("La valeur today est: %d\n", today);
 
    /* Pour faire de l'affichage, on passe par la fonction jour2str() */
    {
        char s_today[10] = {0};
        int err;
        if ((err = jour2str(s_today, sizeof s_today, today)) != JOUR_ERROR)
        {
            printf("Aujourd'hui, nous sommes %s\n", s_today);
        }
        else
        {
            fprintf(stderr, "Jour invalide!");
        }
    }
 
    return EXIT_SUCCESS;
}
 
/**
 * Transforme la valeur d'une variable de type enum Jours en une
 * représentation chaîne de caractères.
 * 
 * @param s_chaine tampon destiné à contenir la représentation 
 *                          en chaîne de caractère de la valiable jour
 * @param taille taille du tampon
 * @param jour jour à représenter sous forme de chaîne de caractères
 * @return code d'erreur vallant 0 si jour est un jour de la semaine valide,
 *             et JOUR_ERROR sinon.
 */
int jour2str(char *s_chaine, size_t taille, enum Jours jour)
{
    int err = 0;
    static char const *s_jours[7] =
        {
            "lundi",
            "mardi",
            "mercredi",
            "jeudi",
            "vendredi",
            "samedi",
            "dimanche"
        };
 
    if (jour >= LUNDI && jour <= DIMANCHE)
    {
        *s_chaine = 0;
        strncat(s_chaine, s_jours[jour], taille - 1);
    }
    else
    {
        err = JOUR_ERROR;
    }
    return err;
}

Il est important de garder à l'esprit que le compilateur ne fait en principe pas de vérification sur la valeur prise par une variable de type enum Jours, par exemple. Les enumérations sont également souvent utilisées pour définir des constantes symboliques représentées par des entiers, comme par exemple les codes d'erreurs retournés par les fonctions.

Une union est une variable qui peut contenir des objets de taille et de types différents, mais pas au même moment. Soit l'unions suivante:

Code :

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

1
2
3
4
5
union Exemple {
    int entier;
    double flottant;
    char *s_chaine;
} u;

Ainsi, la variable u pourra contenir soit un int, soit un double, soit un pointeur sur char. La taille de u sera celle du plus grand de ses champs, et le compilateur fait ce qu'il faut pour que l'alignement soit compatible avec tous les types de l'union.

Ce qu'il est possible de faire avec une union:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
union Exemple {
    int entier;
    double flottant;
    char *s_chaine;
} u;
 
u.entier = 32;
printf("La valeur de u est %d\n", u.entier);
u.flottant = 3.1415;
printf("La valeur de u est %ld\n", u.flottant);
u.s_chaine = "Thierry Chappuis";
printf("La valeur de u est %s\n", u.s_chaine);

C'est au programmeur de savoir quel type est contenu dans la variable u à chaque instant.

Ce qu'on ne peut pas faire avec une union:

Code :

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

1
2
3
4
5
6
7
8
union Exemple {
    int entier;
    double flottant;
    char *s_chaine;
} u;
 
u.flottant = 3.1415;
printf("La valeur de u est %d\n", u.entier); /* ATTENTION! */

Si l'on stocke une valeur d'un type donné dans la variable u, et qu'on y accède via un champ d'un autre type, le résultat dépend de l'implantation. Bien sûr il y a des exceptions, mais on va s'arrêter là pour le moment. N'hésite pas à poser des questions si tel ou tel aspet de l'utilisation des structures, des enumérations et des unions te semble obscure.

EDIT: Grillé par Emmanuel! Ca m'apprendra a laisser la rédaction d'un post en plan... Vu l'effort de rédaction, je poste tout de même.

Cordialement

Thierry