Ce cours contient la notion de type composite en langage C

1. Langage C
Partie 2
Année universitaire
2014/2015
Université Hassan II Casablanca
Ecole normale supérieure (ENS)
Master Mathématiques, Cryptologie et Sécurité Informatique (MMCSI)
Mohamed Lahby
mlahby@gmail.com

2. Langage C (Partie 2)
Types complexes
structures, unions et
énumérations

3. Langage C (Partie 2)
Plan du cours
1.Structures
2.Unions
3.Enumérations

4. Structures
Une structure est un nouveau type de données constitué par un ensemble de
variables (champs) qui peuvent être hétérogènes et de types différents
La différence avec le type tableau est que les champs d’un tableau sont tous
homogènes et du même type
Les structures permettent de représenter des objets réels caractérisées par
plusieurs informations, par exemple :
Une personne caractérisée par son nom (chaîne), son âge (entier), sa taille (réel), ...
Une voiture caractérisée par sa marque (chaîne), sa couleur (chaîne), son année
modèle(entier), ...
4/17

5. Définition d'un modèle de structure
La définition d'un modèle de structure s'effectue en précisant le nom de la
structure, ainsi que le nom et le type de ses champs :
Syntaxe en C : struct nom_structure
{
type 1 nom_champ1;
type 2 nom_champ2;
...
type N nom_champN;
};
Exemple : struct Personne
{ char Nom[20];
int Age;
float taille;
};
Rq: Le nom d’une structure n’est pas un nom de variable, c’est le nom du
type ou modèle de la structure
5/17

6. Déclaration d’une variable structure
La définition d'un modèle de structure ne réserve pas d’espace mémoire
La réservation se fait quand on définit des variables correspondant à ce
modèle de structure. Ceci peut se faire soit
Après la déclaration de la structure, par exemple :
struct Personne p1, p2, tab[10];
//p1 et p2 deux variables de type structure Personne
// tab est une variable de type tableau de 10 éléments (de type Personne)
 ou au moment de la déclaration de la structure
struct Personne
{ char Nom[20];
int Age;
float taille;
} p1, p2, tab[10];
6/17

7. Initialisation d’une structure
Lors de la déclaration d’une variable structure, on peut initialiser ses champs
avec une notation semblable à celle utilisée pour les tableaux en indiquant la
liste des valeurs respectives entre accolades.
 Exemple :
struct date
{ unsigned short jour;
char mois[10];
unsigned short annee;
};
struct date d1= {15,"Novembre", 2013};
7/17

8. Utilisation des champs d’une structure
L'accès à un champ d’une variable structure se fait par le nom de la variable
suivi d’un point et du nom du champ:
nom_variable.nom_champ
Exemples:

p1.age = 15; : affecte la valeur 15 au champ age de la structure p1.

printf ("%f", p1.taille) : affiche, suivant le code format %d, la valeur du champ taille de
la structure p1.

scanf ("%d", &p2.age) ; : lit, suivant le code format %d, une valeur qui sera affectée au
champ age de la structure p2. Notez bien la présence de l’opérateur &
8/17

9. Utilisation globale d’une structure
Il est possible d’affecter à une structure le contenu d’une structure
définie à partir du même modèle.
Exemple : soit la structure article définie par :
struct article
{ int numero; //un numéro qui identifie l’article numero;
int qte; // quantité disponible en stock
float prix;
} art1, art2;
Nous pourrons écrire : art1=art2
Une telle affectation globale remplace avantageusement
art1.numero = art2.numero ;
art1.qte = art2.qte ;
art1.prix = art2.prix ;
9/17

10. Saisie et d’affichage d’une structure
/* Saisie des champs de la structure art */
printf ("Entrez respectivement les champs de l’article n ");
scanf("scanf(" %d %s %d %f" , &art.numero, art.nom, &art.qte_stock, &art.prix);
/* Saisie des champs de la structure art */
printf (" Cet article a pour : n ");
printf (" t numéro : %d n ", art.numero);
printf (" t nom : %s n ", art.nom);
printf (" t quantité en stock : %d n ", art.qte_stock);
printf (" t prix : %f n ", art.prix);
10/17

11. Imbrication de structures
Les structures peuvent être composées de champs de n’importe quel type
connu: types de base, pointeur, tableau ou structure.
Exemple:
struct Etudiant
{ int code;
char Nom[20];
struct date date_naissance;
float notes[8]; //notes de l'étudiant dans 8 modules
} E1,E2;
On peut écrire E1.date_naissance.annee pour accéder au champ annee de
E1.date_naissance qui est de type date
E2.notes[3] représente la note du module 4 de l’étudiant E
11/17

12. Tableaux de structures
Voyez ces déclarations :
struct point { char nom ;
int x ;
int y ;
} ;
struct point courbe [50] ;
La structure point pourrait, par exemple, servir à représenter un point d’un
plan, point qui serait défini par son nom (caractère) et ses deux coordonnées.
point est un nom de modèle de structure, tandis que courbe représente
effectivement un tableau de 50 éléments du type point.
courbe[i].nom: représente le nom du point de rang i du tableau courbe. Il s’agit donc
d’une valeur de type char
 courbe.nom[i] :n’aurait pas de sens!!!!.
12/17

13. Définition de types synonymes: typedef
En C, on peut définir des types nouveaux synonymes de types existants
(simples, pointeur, tableau, structure,...) en utilisant le mot clé typedef. Ces
nouveaux types peuvent être utilisées ensuite comme les types prédéfinis
Exemple :
La déclaration :
typedef int entier ;
signifie que entier est synonyme de int, de sorte que les déclarations suivantes sont
équivalentes :
int n, p ; <--------> entier n, p ;
De même
typedef int * ptr ;
signifie que ptr est synonyme de int *. Les déclarations suivantes sont équivalentes :
int * p1, * p2 ; ptr p1, p2 ;
13/17

14. Application typedef aux structures
En faisant usage de typedef, les déclarations des structures art1 et art2 peuvent
être réalisées comme suit :
struct enreg
{ int numero ;
int qte ;
float prix ;
} ;
typedef struct enreg s_enreg ;
s_enreg art1, art2 ;
ou encore, plus simplement :
typedef struct
{ int numero ;
int qte ;
float prix ;
} s_enreg ;
s_enreg art1, art2 ;
14/17



15. Exercice 1 : Modélisation des nombres complexes
Un nombre complexe z est entièrement défini par ses parties réelle a imaginaire b: z=a+ib
1)Définir la structure qui permet de représenter correctement un nombre complexe.
2)Réaliser les fonctions donnant les attributs d'un nombre complexe (partie réelle, partie
imaginaire, module, argument)
3)Réaliser les fonctions nécessaires à l'arithmétique sur les complexes (addition,
soustraction, multiplication,division, conjugué, multiplication par un réel)
4)Écrire une fonction d'entête: int IdentiqueComplexe(... , ...) qui teste l'égalité de deux
nombres complexes.
5)Ecrire une fonction d'entête void SaisieComplexe1(....); qui permet la saisie au clavier
d’un nombre complexe.
6)Ecrire une fonction d'entête void SaisieComplexe2(...) qui fait le même travail en
passage par adresse.
7)Ecrire une fonction d'entête complexe InitialiserComplexe1() qui permet d'initialiser
un nombre complexe
8)Ecrire une fonction d'entête complexe InitialiserComplexe(float R , float I) qui permet
d'initialiser un nombre complexe
9)Ecrire une fonction d'entête void AfficheComplexe qui permet d’afficher un nombre
complexe a l’écran. Vous passerez le nombre complexe à afficher par adresse.
10) Écrire le programme principale main() qui appel les fonctions précédentes
15/17

16. Exercice 2 : Gestion des notes d'une classe
On souhaite créer un programme en langage C permettant la gestion des notes pour une
classe. Pour cette raison on utilise les deux types de données (structures) définis ci-dessous
pour représenter un Etudiant et une Classe:
typedef struct ETD
{ char nom[30];
char prenom[30];
int age;
float note;
} Etudiant;
La structure Classe qui va représenter la classe des étudiants. adresses. Cette structure
Classe contiendra un tableau de 30 étudiants et un compteur (un entier nommé n) indiquant
le nombre des étudiants dans le tableau E.
typedef struct CLS
{ Etudiant E[30];
int n;
} Classe;
16/17

17. Exercice 2 : Gestion des notes d'une classe
1)Ecrire une fonction d'entête Etudiant saisir1_etudiant(void) saisissant au clavier les données
constituant un objet de type Etudiant.
2)Ecrire une fonction d'entête void saisir2_etudiant(Etudiant *I) saisissant au clavier les
données constituant un objet de type Etudiant.
3)Ecrire une fonction d'entête int identiques(Etudiant m1,Etudiant m2) retournant 1 si les
champs nom (considéré comme une chaîne de caractères) et age de m1 et m2 ont les mêmes
valeurs, et 0 sinon.
4)Ecrire une fonction d'entête void ajouter_etudiant(Etudiant I, Classe C) qui ajoute l'étudiant
I dans la classe C (on insère l'élément à la fin du tableau).
5)Ecrire une fonction d'entête float moy_classe(Classe C)qui permet de retourner la moyenne
de tous les étudiants de la classe C.
6)Ecrire une fonction d'entête void afficher_etudiant(Etudiant I) qui affiche les informations
contenues dans l’objet I passée en argument.
7)Ecrire une fonction d'entête void afficher_liste(Classe C) affichant à l'écran une représentation
lisible de tous les étudiants de classe C.
8)Ecrire une fonction d'entête int position(Etudiant m , Classe C) retournant l'indice où l'on
trouve m dans A (-1 si m n'est pas dans l'annuaire).
9)Ecrire une fonction d'entête float Chercher_Note_Max(Classe C) retournant le nom de
l'étudiant ayant la note la plus élevée dans la classe C.
10)Ecrire une fonction int Nbr_Etd_moy(Classe C) retournant le nombre des étudiants ayant
obtenu une notre supérieure ou égale à la moyenne de la classe. 17/17