TP Langage C Les Structs

TP1 : Les Enregistrements (Struct)

Exercice N°1 :
Ecrire un programme qui permet de remplir les éléments de la structure Matiere définit par
CodeMat, LibelleMat, NbreHeureMat, CoefMat, Niveau.
Appliquer les différentes manipulations possibles sue cette structure (déclaration des
variables, initialisation, affectation globale, saisie et changements des valeurs, …)

Exercice 2 : nombre rationnel

Un nombre est dit rationnel s’il s’écrit comme étant le rapport de deux entiers relatifs : le
numérateur et le dénominateur. Ecrire un programme C permettant de définir la structure de
données relative à la définition d’un nombre rationnel (Nbre_rationnel).
- Saisir deux nombres rationnels r1 et r2 sous la forme :
Entrer Numérateur du nombre1 : ******
Entrer Dénominateur du nombre1 : ******
Entrer Numérateur du nombre2 : ******
Entrer Dénominateur du nombre2 : ******
- Afficher les deux rationnels, les multiplier et présenter les résultats sous la forme rationnelle
- Additionner les deux rationnels, les multiplier et présenter les résultats sous la forme
rationnelle

Exercice 3 : Comparaison de date

I- Déclarer une structure date contenant trois champs jour, moi et année.
II- Ecrire une fonction int cmp_date(date d1,date d2) permettant de comparer les dates,
retournant AVANT (ou 1) si la date d1 est antérieur à la date d2, APRES (ou -1) si elle est
postérieur, EGAL (ou 0) lors d’une égalité.
III- Ecrire une procédure d’appel de cette fonction.

Exercice 4 : Saisie de note

I- Déclarer une structure fiche contenant quatre champs nom, prenom, age et note.
II- Ecrire une fonction void saisir_fiche(fiche*F) permettant de saisir une fiche.
III- Ecrire une fonction void afficher_fiche(fiche F) permettant d’affiche une fiche.
Ecrire une procédure d’appel des deux fonctions précédentes.

Exercice 5 : Heure
Définir une structure heure permettant de représenter une heure sous le format hh/mm/ss.
Écrire les fonctions suivantes (ainsi qu'une fonction main les utilisant) :
- Conversion d'une heure en nombre de secondes.
- Conversion d'un nombre en secondes en un élément de type heure.
- Addition de deux éléments de type heure, d'abord en utilisant les fonctions précédentes puis
sans les utiliser.

Exercice 6 :
Créer une structure point_cartesien{float x; float y;} ;
Saisir 4 points, les ranger dans un tableau puis les afficher.
Créer une deuxième structure point_polaire {float r ;float t ;} ;
Transformer les point_cartesiens en des point_polaires à l’aide de la fonction cart_to_pol.
Afficher les nouveaux points.
TP Langage C Les Structs

Exercice 7 :
Une image est décrite comme étant une composition de primitives graphiques. On considère
trois primitives graphiques :
- Cercle : définit par les coordonnées de son centre et son rayon.
- Rectangle : définit par les coordonnées des points « haut gauche » et « bas droit ».
- Polygone : défini par le nombre de cotés et les coordonnées des points le définissant.
Les coordonnées des points sont des paires de nombre entier.
Une image est constituée comme suit :
Cercle (X,Y),R
Rectangle (X,Y),(Z,T)
Polygone Nb, (X1,Y1),.
I- Définir les types cercle, rectangle et polygone.
II- Définir le type image correspondant à la description d’une image.
III- Permettre à l’utilisateur de dessiner plusieurs images.

Exercice 8 :
Partie 1 : On définit une pièce (dans un logement) par sa superficie, le nombre de personnes
qui dorment dedans et le nombre de chaises qu'on y trouve. Dans un même fichier C :
a- Définir un nouveau type piece.
b- Ecrire une fonction de saisie ayant pour profil piece saisie_piece() qui rend une valeur
de type piece, dont la valeur des champs est demandée à l'utilisateur.
c- L'opérateur == ne s'applique pas aux structures. Définir alors une fonction int
egal_piece(piece p1, piece p2) qui rend 1 si les pièces sont égales (comparaisons de tous les
champs des deux structures) et 0 sinon.
Ecrire ensuite une fonction de comparaison piece comp_piece(piece p1, piece p2) qui rend la
plus grande pièce parmi deux.
d- Ecrire la fonction main() déclarant 3 pièces, demandant les données à l'utilisateur et,
pour finir, affichant la superficie de la pièce la plus grande.

Partie 2 : Ajouter un type appart composé de 3 pièces et d'un entier indiquant le nombre
d'enfants qui l'occupent. On écrira ensuite une fonction appart saisie_appart() de saisie des
données d'un appartement. Pour finir, il s'agira d'écrire la fonction principale dans laquelle on
demande la saisie des données d'un tel appartement puis on affiche:
- La superficie totale.
- Le nombre total de chaises qu'on y trouve
TP Langage C Les Structs

ANNEXE TP1 : Les Enregistrements (Struct)

1. Les structures ou enregistrements
1.1. Définition : Une structure est un agrégat de plusieurs objets de types différents; elle
permet de regrouper dans une même variable plusieurs informations complémentaires de
types hétérogènes appelé champs. Chaque champ est définit par un identificateur et un type.
1.2. Déclaration : La déclaration d'une structure se fait par le mot réservé struct suivi d'une
liste de déclaration de variables entre accolades. Attention car il y a un ; à la fin des accolades.
Syntaxe :
struct id_struct{
type1 champ1 ;
type2 champ2 ;
....
typeN champN ;
};

Exemple : Pour une application de gestion de stock, on peut définir la structure PRODUIT et
qui contient l’ensemble de ses caractéristiques tel que identifiant de l’article, nom du produit,
unité, quantité, prix… D’où la structure suivante :
struct PRODUIT{
int identifiant ;
char nom[20] ;
char unite[10] ;
int quantite ;
float prix ;
};
Pour déclarer une variable de type structure, on suit la syntaxe suivante :
struct id_struct{
type1 champ1 ;
type2 champ2 ;
....
typeN champN ;
}id_var1;
Il est possible, après avoir déclaré la structure, d’ajouter la ligne suivante :
struct id_struct id_var1 ;

1.3. Initialisation : Il est possible d'initialiser une structure lors de sa déclaration :

struct PRODUIT prod = {115, “coca“, “bouteille“, 150, 520.25 } ;

1.4. Accès aux champs d’une structure : Les champs d’une structure peuvent être accédés
directement par leur nom au moyen d’une notation "pointée". Il suffit en effet de mettre le
nom de la variable de type structure, un point (opérateur) et le nom du champ pour accéder à
son contenu, y stocker une valeur : nom_variable.nom_champ
Exemple :
struct PRODUIT prod ;
prod.identifiant=115 ;
prod.nom= “coca“;
prod.unite=“bouteille“ ;
prod.quantite=150 ;
prod.prix=520.25 ;
int ident ;
ident=prod.identifiant ;
TP Langage C Les Structs

2. Les unions :
2.1. Définition : Les unions sont de nouvelles structures de données assez proches des
structures. Elles permettent de considérer un même objet de différents points de vue. Selon les
besoins du programmeur, il pourra revêtir des formes diverses. Une union permet de définir
un objet comme pouvant être d'un type au choix parmi un ensemble fini de types, appelés les
membres de l'union. Un membre de l'union est identifié par un identificateur, le nom du membre.
L'union occupera en mémoire la place nécessaire pour représenter le membre le plus "grand".
Dans le programme, un programmeur pourra décider le type à donner à l'union avec un opérateur
de sélection.

2.2. Déclaration : La déclaration de l’union se fait par le mot réservé union suivi d'une liste
de membres entre accolades.
union nom {
type1 champ1;
type2 champ2;
...
typeN champN;
};
Exemple :
union exemple {
char car_val; /* contient un caractère */
int ent_val; /* ou un entier */
float flo_val; /* ou un flottant */
char tex_val[10]; /* ou du texte */
};
union exemple data;
data.flo_val = 123.425;
printf ("%f", data.flo_val); /* est valide */
printf ("%d", data.ent_val); /* n’a pas de sens car
l’union contient un float.*/

3.Les enumerations
3.1. Définition : Il arrive fréquemment que la valeur d’une variable fasse partie d’un
ensemble fini de symboles. On parle dans ce cas de types énumérés car il est possible de
décrire complètement la liste de toutes les valeurs possibles.

3.2. Déclaration : La déclaration d’une énumération se fait par le mot réservé enum suivi de
la liste des valeurs entre accolades.
enum Nom {
val1,
Val2,
.....,
ValN
};
Exemple : On déclare l’énumération jour pouvant prendre une valeur parmi les valeurs de
lundi à dimanche.
enum jour {
lundi,
mardi,
mercredi,
jeudi,
vendredi,
TP Langage C Les Structs

samed
i,
diman
che
} ;
enum jour J=jeudi ;
Remarque : Le compilateur assigne une valeur par défaut à chaque élément de la liste
en commençant par 0 et en incrémentant à chaque fois. Exemple :
enum jour {
lundi=6,
mardi=5,
mercredi
=4,
jeudi=3,
vendredi
=2,
samedi=1
,
dimanche
=0
} ;
enum jour weekend,
fin_sem;
weekend=dimanche;
fin_sem=samedi ;
printf(“%s“,weekend) ; /* affiche dimanche */
printf(“%d“,fin_sem) ; /* affiche 1 */

4. Les types utilisateurs

4.1. Définition : On a vu les types de variables utilisés par le langage C: char, int, float,
etc.
Le programmeur a la possibilité de créer ses propres types: Il suffit de les déclarer en
début de programme (après les déclarations des bibliothèques) avec la syntaxe suivante:
typedef type_existant identificateur;
Exemples :
typedef int entier; /*on définit un nouveau
type
"entier" synonyme de "int" */
typedef int vecteur[3]; /*on définit un nouveau type
"vecteur" synonyme d’un tableau de 3
entiers */
Remarque : La portée de la déclaration de type dépend de l'endroit où elle est déclarée: dans
main(), le type n'est connu que de main(); en début de programme, le type est reconnu dans
tout le programme. Exemple :
#include <stdio.h>
typedef int entier;
typedef float
point[2]; typedef
enum {
lundi =
TP Langage C Les Structs

6, mardi
= 5,
mercredi =
4, jeudi
= 3,
vendredi =
2, samedi
= 1,
dimanche =
0
} JOUR;
void main(){
entier n =
6; point
xy; xy[0]
= 8.6;
xy[1] = -9.45;
JOUR jour = lundi;
etc
...}