Cours de programmation C

Les structures

I. Le type structure :

Un enregistrement, appelé structure En langage C, est une variable complexe qui

permet de désigner sous un seul nom un ensemble de valeurs pouvant être de types
différents.

Déclaration : Lors de la déclaration de la structure, on définit un modèle où on indique

les champs de la structure, c'est-à-dire le type et le nom des variables qui la composent.
La syntaxe associée est comme suit :
struct <Nom_Structure> {
<type_champ1> <Nom_Champ1>;
<type_champ2> <Nom_Champ2>;
<type_champ3> <Nom_Champ3>;
...
};
Exemple :

struct Etudiant { int Age;

char Nom[20];
char Prenom[20];
float Notes [4];
float Moyenne;
};
struct Etudiant Etudiant1, Etudiant2;

Chaque variable de type structure possède des champs repérés avec des noms uniques.
Toutefois le nom des champs ne suffit pas pour y accéder étant donné qu'ils n'ont de contexte
qu'au sein de la variable structurée. Pour accéder aux champs d'une structure on utilise
l'opérateur de champ (un simple point) placé entre le nom de la variable structurée et le nom
du champ.

Syntaxe :
<Var_Structure>.<Nom_Champi>;

Ainsi, pour affecter des valeurs à la variable Etudiant1, on pourra écrire :

Etudiant1.Age = 2;
scanf ("%f", &Etudiant1.moyenne) ;
printf ("%f", Etudiant1.moyenne) ;
Il est clair, qu’on peut effectuer des affectations entre deux variables de même type de
structure :
 soit d’une façon individuelle (champs par champs), sur chacun de leurs champs,
 soit d’une manière globale sur toute la structure.
Exemple :
Affectation individuelle :
Etudiant1. Age = Etudiant2.Age;
Etudiant1.Moyenne = Etudiant2.Moyenne;
Affectation Globale :
Etudiant1 = Etudiant2;
Remarques :
 L’affectation globale n’est valable que si le compilateur utilisé se base sur le standard
ANSI C.
 Pour comparer deux structures, il est impératif de passer par la comparaison
individuelle des champs.

Notation :
Etudiant1.nom[0] : désigne le premier caractère du champ nom de l’étudiant
Etudiant1.
Etudiant2.notes[3] : désigne la quatrième note du tableau notes de l’étudiant
Etudiant2.
Utilisation :
strcpy (Etudiant1.nom, "Ben Salem");
Etudiant1.notes[2] = 13.6;
printf (“%f “, Etudiant2.notes[i]);

II. Définition de type : typedef

La déclaration typedef permet de définir ce que l’on nomme en Langage C des types
synonymes. Il est à noter que cette déclaration s’applique à tous les types et pas seulement aux
structures.

Syntaxe :

typedef <type> <Nom_Nouveau_Type>;

Pour le cas des structures :

typedef struct <Nom_Structure> <Nom_Nouveau_Type>;

Exemple :

typedef int entier;

typedef struct Etudiant ETUDIANT;

III.Structure comportant d’autres structures :

Une structure peut contenir aussi des champs de type structure. Cette dernière -- la structure
imbriquée -- doit être différente de la première.
Exemple :
struct date { int jour;
int mois;
int annee;
 };
struct UnEtudiant { char nom [30] ;
char prenom [30] ;
struct date date_naissance ;
} Etudiant1;
Utilisation :
Etudiant1.date_naissance.jour = 1;
scanf ("%d %d %d", &Etudiant1.date_naissance.jour,
&Etudiant1.date_naissance.mois, &Etudiant1.date_naissance.annee);

IV. Tableaux de structures :

Etant donné qu'une structure est composée d'éléments de taille fixes, il est possible de créer un
tableau ne contenant que des éléments du type d'une structure donnée. Il suffit de créer un
tableau dont le type est celui de la structure et de le repérer par un nom de variable :
Déclaration :
struct <Nom_Structure>
{ <type_champ1> <Nom_Champ1>;
…
<type_champN> <Nom_ChampN>;

};
struct <Nom_Structure> <Tab_Struct1>[N1], ..., <Tab_StructN>[Nn] ;
Accès :
à un élément du tableau :
<Tab_Struct>[i] (structure N° i)

à un élément (champ N° j) d’une structure d’indice i dans le tableau de structure

associé :
<TabStruct>[i].<NomChampj>

Exemple :

#include<stdio.h>
#include<conio.h>

struct UnEtudiant {
char nom[30];
char prenom[30];
float notes[4];
};
typedef struct UnEtudiant Etudiants ;
void main()
{
Etudiants t[3];
int i, j;
float x;
clrscr();
for (i = 0; i < 3; i++)
 {
printf ("Entrez le nom de l'étudiant %d : ", i+1);
scanf ("%s", t[i].nom);
printf ("Entrez le prénom de l'étudiant %d : ", i+1);
scanf ("%s", t[i].prenom);
for (j =0; j < 4; j++)
{
do
{
printf ("Entrez la note %d de l'étudiant %d : ", j+1, i+1);
scanf ("%f", &x);
t[i].notes[j]=x;
}while(t[i].notes[j]<0||t[i].notes[j]>20);
}
}
for (i = 0; i < 3; i++)
{
printf ("le nom de l'étudiant %s\n ", t[i].nom);
printf ("le prénom de l'étudiant %s\n ", t[i].prenom);
printf (" les notes de l'étudiant %d : ", i+1);
for (j =0; j < 4; j++)
printf ("%.3f ", t[i].notes[j]);
}
getch();
}

Application 1 :
Créer une structure fiche contenant les informations suivantes :
 Nom sur 20 caractères
 Prénom sur 20 caractères
 Age de type entier
 Note de type réel
Saisir une fiche et puis l’afficher.

#include <stdio.h>
#include <conio.h>
struct fiche
{
char nom[21];
char prenom[21];
int age;
float note;
};
void main()
{
fiche f;
printf("SAISIE D'UNE FICHE \n");
printf("NOM: ");gets(f.nom);
printf("PRENOM: ");gets(f.prenom);
printf("AGE: ");scanf("%d",&f.age);
printf("NOTE: ");scanf("%f",&f.note);
printf("\n\nLECTURE DE LA FICHE:\n");
printf("NOM: %s PRENOM: %s AGE: %2d NOTE: %4.1f",
f.nom,f.prenom,f.age,f.note);
printf("\n\nPOUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}

Application 2 :
Créer une structure point contenant les informations suivantes :
 num de type entier
 x de type réel
 y de type réel
Saisir 4 points les ranger dans un tableau et puis les afficher.
#include <stdio.h>
#include <conio.h>
struct point {int num;float x;float y;};
void main()
{
point p[4]; /* tableau de points */
int i;
float xx,yy;
/* saisie */
printf("SAISIE DES POINTS\n\n");
for(i=0;i<4;i++)
{
printf("\n Point Nº%1d\n",i);
p[i].num = i;
printf("X= "); scanf("%f",&xx);
printf("Y= "); scanf("%f",&yy);
p[i].x = xx; p[i].y = yy;
}
/* relecture */
printf("\n\nAFFICHAGE DES POINTS\n\n");
for(i=0;i<4;i++)
{
printf("\nPOINT Nº%1d",p[i].num);
printf("\nX= %f",p[i].x);
printf("\nY= %f\n",p[i].y);
}
printf("\n\nPOUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}

Exercices

Exercice 1 : Soit une structure DATE contenant les champs suivants :

- jour : chaîne de caractères de taille 3,
- mois : chaîne de caractères de taille 3,
- année : chaîne de caractères de taille 5.

1- Ecrire une fonction qui permet de saisir le contenu d’une variable d de type DATE. Les
contrôles de saisie nécessaires doivent être effectués.

2- Soit une fonction qui prend en paramètre une variable d de type DATE et une variable n
contenant un nombre positif de jours. Cette fonction permettra d’incrémenter le contenu
de d par celui de n. Ecrire le code source de cette fonction.

3- Ecrire une fonction qui permet d’afficher le contenu d’une variable date.

4- Ecrire un programme qui saisit une date, incrémente son contenu et affiche la nouvelle
date.

Exercice 2 : Le but de cet exercice est d’écrire un programme C qui permet de mémoriser
dans un tableau les informations relatives aux 15 joueurs d’une équipe de rugby et de traiter
ces informations. Un joueur est caractérisé par son nom, son prénom et son poids. Chaque
joueur à un numéro de poste (de 1 à 15) qui détermine son rôle dans l’équipe (numéro 1 est le
pilier gauche, le numéro 2 est le talonneur, etc.).

1. Ecrire une procédure qui permet de remplir un tableau par les informations
concernant tous les joueurs (numéro, nom, prénom, poids). Les contrôles de saisie
nécessaires doivent être effectués concernant les champs numéro et poids. Cette
procédure affiche ensuite les informations saisies une fois le tableau rempli.
2. Ecrire une procédure permettant d’afficher le poids, le numéro de poste, le nom et le
prénom du joueur le plus lourd de l’équipe d’une part et le poids moyen des
joueurs d’autre part.
Exercice 3 : Le but de cet exercice est de développer un programme C permettant de gérer le
stock d’un fournisseur de produits bureautiques. On suppose que le stock (tableau d’articles)
est composé de 100 produits au maximum. Chaque produit a un modèle (chaîne de caractère
de 20 caractères au plus), un prix unitaire et une quantité disponible.
 Définir la structure article qui permet de représenter un article.
 Ecrire une procédure appelée ajouterArticle qui permet d’ajouter un nouvel article au
tableau représentant le stock et qui prend comme paramètres un article et une position
d’insertion.
 Ecrire un programme principal permettant de remplir le stock avec un ensemble
d’articles saisis par l’utilisateur.
Définir la structure commande qui représente une commande d’achat passée par un client.
Une commande est constituée par le nom du client (chaîne de caractères) et d’un ensemble de
commandes unitaires (tableau de structure commandeUnitaire de taille maximale 100). Une
commande unitaire comporte le modèle de l’article concerné et la quantité demandée.
 Définir les structures commandeUnitaire et commande.
 Ecrire une fonction qui prend en paramètre un tableau vide de commandes unitaires et
qui permet de saisir l’ensemble des modèles désirés et la quantité demandée pour
chacun.
 Ecrire une fonction appelée retirerCommandeUnitaire qui prend comme paramètres le
stock et une commande unitaire, recherche le modèle dans le stock et :
o Si la quantité disponible est suffisante, la met à jour et retourne le prix de celle-
ci.
o Si le produit n’existe pas ou si la quantité est insuffisante, informe l’utilisateur
et retourne 0.
Modifier le programme principal précédent de manière à :
 Afficher le stock initial.
 Constituer une commande de plusieurs produits.
 Retirer la commande et afficher son prix total.