Programmation Structurée

Chapitre III:
Les types composés
partie 3

Pr Bekkari 1
Cycle préparatoire de l’ENSA de Marrakech
Année universitaire 2024 - 2025 09/10/2024
Contenu du chapitre
1) Les tableaux
• à 1 dimension

• à 2 dimensions

2) Les tableaux de caractères

3) Les structures

4) Définition de nouveaux types avec typedef

5) Les types énumérés

6) Les Unions 2

09/10/2024
Les structures
• Une structure est une suite finie d’objets de types différents
• Les différents éléments d’une structure n’occupent pas
nécessairement des zones contiguës en mémoire
• Chaque élément de la structure, appelé membre ou champ,
est désigné par un identificateur
• Syntaxe de déclaration d’un modèle de structure:
struct modele {
type_1 nom_champ_1;
type_2 nom_champ_2;
...
type_n nom_champ_n;
};
3

09/10/2024
Les structures
• Syntaxe de déclaration d’un objet de ce modèle de structure:
struct modele objet; //objet est une variable du modele
• Il est possible de déclarer les deux en même temps:
struct modele {
type_1 nom_champ_1;
type_2 nom_champ_2;
...
type_n nom_champ_n;
} objet;
• Exemple1: Exemple 2:
struct coordonnees { struct ficheEtudiant{
int x; char nom[50];
int y; int age;
}; float notes[4];
struct coordonnees point; } f; 4

09/10/2024
Les structures
• Représentation des exemples:
Exemple 1: structure Exemple 2: structure ficheEtudiant
coordonnées

4 16 durant 20 12 14.5 18 11
x y
nom age notes
Objet point
Objet f
• Initialisation de l’objet à la déclaration (séquentielle):
struct coordonnees point= {4, 16};
struct ficheEtudiant f = {ʺdurantʺ, 20, {12,14.5,18,11}};
• Initialisation de l’objet à la déclaration(sélective):
struct coordonnees point= {.x=4, .y=16};
struct ficheEtudiant f = {ʺdurantʺ, .age=20}; //mélange des deux
• Utilisation de l’objet du modèle: objet.nom_champ 5
Exemples: f.nom=ʺdurantʺ; f.age = 20; f.notes[1]=14.5; point.x=4;
point.y=16
09/10/2024
Les structures
• Exemple :
• Soit la structure suivante:
#define N 4
struct ficheEtudiant{
char nom[50];
int age;
float notes[N];
};

• Saisir un étudiant puis calculer et afficher la moyenne de ses

notes

10/10/2024
 Les structures
#include<stdio.h>
#define N 4
struct ficheEtudiant{
char nom[50]; int age; float notes[N];
};
int main(){
struct ficheEtudiant f;
int i; float som = 0, moy ;
printf(ʺsaisissez le nom de l\’etudiant: ʺ); scanf(ʺ%sʺ, f.nom);
printf(ʺ\nsaisissez l’age de l\’etudiant: ʺ); scanf(ʺ%dʺ, &f.age);
printf(ʺ\nsaisissez les notes de l\’etudiant: ʺ);
for(i=0;i<N;i++) {
printf(ʺ\nsaisissez note %d: ʺ, i+1);
scanf(ʺ%fʺ, &f.notes[i]);
som = som + f.notes[i];
}
moy = som/N;
printf(ʺ\nL\’etudiant %s d\’age %d a pour moyenne du semestre: %.2fʺ, f.nom, f.age, 7
moy);
}
10/10/2024
Définition de types avec typedef
• typedef permet d’affecter un nouvel identificateur à un type
composé : implique la création de nouveaux types (allège
l’écriture de programmes notamment dans le cas des tableaux et des
passages en paramètres des arguments dans les fonctions)
• Syntaxe: typedef déclaration; //à mettre au début du
programme, de préférence
avant le main()
• Exemple avec une structure:
typedef struct ficheEtudiant{
char nom[50];
int age;
float notes[4]; //ici FICHE est un nouveau
} FICHE; type et non pas un objet
8

10/10/2024
 Définition de types avec typedef
• Déclaration de variables : nouveau_type variable;
• Exemples:
FICHE f; //f est une variable de type FICHE
FICHE t[10]; //t est un tableau de 10 éléments de type FICHE
• Représentation de la variable t (tableau de FICHE):

t
…

nom age notes nom age notes

0 1 2 …
Exemples d’affectations:
t[0].age = 20; 9
t[0].notes[2] = 14.5; //t[i].notes[j]
10/10/2024
Définition de types avec typedef
• Utilisation de typedef avec les tableaux:
• Exemple avec le nouveau type FICHE :
typedef FICHE TABF[10]; //définition d’un type TABF de type FICHE
TABF devient un type tableau de
FICHE à 1 dimension
• Autre exemple :
typedef int MATRICE[10][20]; //définition d’un type MATRICE d’entiers
MATRICE devient un type
tableau d’entiers à 2 dimensions
• Déclaration de variables avec les types tableaux:
• Exemples:
TABF t; // t est une variable tableau de type TABF (équivalent à FICHE t[10])

MATRICE m; //m est une variable tableau de type MATRICE 10

10/10/2024
Exemple global
Soit la structure suivante: struct ficheEtudiant{
char nom[50];
int age;
float notes[4];
};

Objectifs:
1) Créer un type FICHE de la structure ficheEtudiant puis un type
tableau de 5 FICHE
2) Remplir le tableau de FICHE
3) Afficher les informations sur l’étudiant x

11

10/10/2024
Solution
• Déclarations :
#include<stdio.h>
#include<string.h>
#define N 5
struct ficheEtudiant{
char nom[50];
int age;
float notes[4];
};
typedef struct ficheEtudiant FICHE; //création du type FICHE
typedef FICHE TABF[N]; //création d’un type tableau de FICHE

int main(){
int i,j;
TABF t; //déclaration du tableau de 5 FICHE
char nomx[20]; 12

10/10/2024
Solution
• Saisie de N étudiants:
for(i=0;i<N;i++){
printf("saississez le nom de l'etudiant %d:", i+1);
scanf("%s", t[i].nom);
printf("saississez l'age de l'etudiant %d: ", i+1);
scanf("%d", &t[i].age);
for(j=0;j<4;j++){
printf("saississez la note %d: ", j+1);
scanf("%f",&t[i].notes[j]);
}
}

13

10/10/2024
Solution
• Recherche de l’étudiant x:
printf("saisissez un etudiant: ");
scanf("%s", nomx);
for(i=0;i<N;i++){
if(strcmp(nomx,t[i].nom)==0){
printf("\ninformation sur l'etudiant %s: ", t[i].nom);
printf("\nage: %d",t[i].age);
for(j=0;j<4;j++){
printf("\nnote %d: %f", j+1, t[i].notes[j]);
}
printf("\n");
}
}

} 14

10/10/2024
Définition de types avec typedef
• Remarque:il est possible d’utiliser un type nouveau dans la
déclaration d’un champ d’un modèle de structure.
• Exemple: On déclare un modèle pour les notes:
typedef struct {
char matiere[30]; //le nom du modèle est
float note; facultatif quand on créé un
} NOTE; nouveau type avec typedef

On utilise maintenant le type NOTE pour déclarer un tableau

de 4 notes dans le type FICHE:
typedef struct ficheEtudiant{
char nom[50];
int age;
NOTE tabNote[4]; 15
} FICHE;
10/10/2024
Définition de types avec typedef
type NOTE : type FICHE :

typedef struct { typedef struct ficheEtudiant{

char matiere[30]; char nom[50];
float note; int age;
} NOTE; NOTE tabNote[4];
} FICHE;

• Pour accéder à une note en utilisant un tableau de FICHE:

• Quelque soit l’écriture de déclaration du tableau:
FICHE t[10] ou typedef FICHE TABF[10];
TABF t;
Il faut aller dans chaque niveau de champ:
• t[i].tabNote[j].matiere
• t[i].tabNote[j].note
16

10/10/2024
Définition de types avec typedef
• Exemple pour la saisie des notes:
for(i=0; i<N;i++){
… //saisie des autres champs de FICHE
//saisie des notes:
printf(ʺ\nsaisissez les notes de l’etudiant: ʺ);
for(j=0;j<4;j++) {
printf(ʺ\nsaisissez matiere %d: ʺ, j+1);
scanf(ʺ%sʺ, t[i].tabNote[j].matiere);
printf(ʺ\nsaisissez note %d: ʺ, j+1);
scanf(ʺ%fʺ, &t[i].tabNote[j].note);
}
}

17

10/10/2024
Les types énumérés
• Les énumérations permettent de définir un type par la liste
des valeurs qu’il peut prendre.
• Un objet de type énumération est défini par le mot-clef enum
et un identificateur de modèle, suivis de la liste des valeurs
que peut prendre cet objet;

• Syntaxe de déclaration d’un modèle d’une énumération :

enum modele { const_1, const_2, ... const_n};

18

10/10/2024
Les types énumérés
• En réalité, les objets de type enum sont représentés comme
des int. Les valeurs possibles const_1, const_2,...,const_n sont
codées par des entiers de 0 à n-1.
• Par exemple, le type enum booleen défini dans le programme
suivant associe l’entier 0 à la valeur faux et l’entier 1 à la
valeur vrai.
#include <stdio.h>
enum booleen {faux, vrai};
int main( ) {
enum booleen b;
b = vrai;
printf("b = %d\n",b); b=1
return 0;
} 19

10/10/2024
 Les types énumérés
• Remarques:
• On peut affecter ou comparer des variables de types
énumérés.
• Un type énuméré est considéré comme de type int : la
numérotation commence à 0, toutefois, il est possible de
préciser la valeur de certaines constantes (voire de
toutes les constantes) à l’aide d’une affectation.
enum naturel { DIX = 10, ONZE, DOUZE, TREIZE, QUATORZE, QUINZE };

enum naturel { DIX = 10, ONZE=11, DOUZE=12, TREIZE=13, QUATORZE=14, QUINZE=15 };

20

10/10/2024
Les types énumérés
• en utilisant un typedef :
typedef enum jours // facultatif
{ lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche
} Day;

Day j;

j= dimanche;
if (j == dimanche) printf(" programme du dimanche");

21

10/10/2024
Les types énumérés
• Quel est le résultat du programme suivant:
#include <stdio.h>
enum Lights { green, yellow, red };
enum Cards { diamond=1, spade=-5, club=7, heart };
enum Operator { Plus = '+', Min = '-', Mult = '*', Div = '/' };
int main () {
enum Lights feux = red;
enum Cards jeu = spade;
enum Operator op = Min;
printf("L = %d %d %d\n", green, yellow, red); L=012
printf("C = %d %d %d %d\n", diamond, spade, club, heart); C = 1 -5 7 8
printf("O = %d %d %d %d\n", Plus, Min, Mult, Div); O = 43 45 42 47
jeu = yellow; erreur
printf("%d %d %c\n", feux, jeu, op); 2 -5 -
return 0; 22
}
10/10/2024
Les unions
• Une union permet de désigner un seul espace mémoire, et de
permettre d'y accéder de plusieurs moyens différents.
• En somme, une union est un regroupement de plusieurs types
de données, qui permettent tous d'accéder au même
emplacement mémoire.
• Syntaxe de déclaration d’un modèle d’une union:

union modele {
type_1 nom_champ_1;
type_2 nom_champ_2;
...
type_n nom_champ_n;
};
23

10/10/2024
Les unions
• Syntaxe de déclaration d’un objet de ce modèle d’une union:
union modele objet; //objet est une variable du modele
• Il est possible de déclarer les deux en même temps:
union modele {
type_1 nom_champ_1;
type_2 nom_champ_2;
...
type_n nom_champ_n;
} objet;
• Exemple:
union type {
int entier;
double flottant;
char lettre;
}; //X; 24
union type X;

10/10/2024
Les unions
• Représentation mémoire:
Exemple :
Union UN{
short a;
long b;
float c;
} mon_union;

• Le type float étant celui qui occupe le plus de place en

mémoire, une variable du type de cette union occupera en
mémoire la taille d'un float, dans ce cas.

• Ensuite, si nous adressons une variable du type de cette union

par le champ de type short, nous n'utiliserons qu'une partie
de l'espace mémoire occupé par cette variable. 25

10/10/2024
Les unions
• Soit le programme suivant:
#include <stdio.h>
union type {
int entier;
double flottant;
char lettre;
};
int main() {
printf("%u\n", sizeof (union type)); 8
return 0;
}

• Le code ci-dessus défini une union type pouvant contenir un

objet de type int ou de type double ou de type char.
• Cette possibilité de ne stocker qu’un objet à la fois est traduite
par le résultat de l’opérateur sizeof. 26

10/10/2024
Les unions
• Pour ce qui est de l'utilisation, il en va exactement de la
même manière que pour les structures.
Exemple1 : Exemple2 :
union union union_2
{ {
short a; short a;
long b; float b;
float c; };
} mon_union;
union union_2 X;
mon_union.a = 10;
mon_union.b = 70900; X.a = 10;
mon_union.c = 3.14; X.b = 3.14;

27

10/10/2024
Les unions
• en utilisant un typedef :
typedef union
{
short a;
float b;
} MON_UNION;

MON_UNION X;
X.a = 10;
X.b = 3.14;

28

10/10/2024
Les unions
• Remarque: une union peut accueillir la valeur de
n’importe lequel de ses membres, mais un seul à la fois.
#include <stdio.h>
#include <string.h>
union MaUnion {
int a;
float b; maunion.a : 1785622338
char tab[10]; maunion.b : 72062436308247284757299200.000000
} maunion; maunion.tab : Bonjour
int main( ) {
union MaUnion maunion;
maunion.a = 10;
maunion.b = 220.5;
strcpy( maunion.tab, "Bonjour");
printf( "maunion.a : %d\n", maunion.a);
printf( "maunion.b : %f\n", maunion.b);
printf( "maunion.tab : %s\n", maunion.tab); 29
return 0;
}
10/10/2024
Les unions
• Ici, tous les membres s’affichent très bien parce que
chaque membre est utilisé à la fois.
#include <stdio.h>
#include <string.h>
union MaUnion {
int a;
float b;
char tab[10];
} maunion;
int main( ) {
union MaUnion maunion; maunion.a : 10
maunion.a = 10; maunion.b : 220.500000
printf( "maunion.a : %d\n", maunion.a); maunion.tab : Bonjour
maunion.b = 220.5;
printf( "maunion.b : %f\n", maunion.b);
strcpy( maunion.tab, "Bonjour");
printf( "maunion.tab : %s\n", maunion.tab); 30
return 0;
}
10/10/2024
Exercice d’application
• Vous souhaitez demander à l’utilisateur deux mesures de temps
sous la forme heure(s):minute(s):seconde(s).milliseconde(s) et lui
donner la différence entre les deux en secondes.
• Ecrire un programme qui permet de réaliser ceci en utilisant une
structure.
• Voici un exemple d’utilisation:

Première mesure (hh:mm:ss.xxx) : 12:45:50.640

Deuxième mesure (hh:mm:ss.xxx) : 13:30:35.480
Il y 2684.840 seconde(s) de différence.
31

10/10/2024
Exercice d’application: solution
#include<stdio.h>
struct temps { unsigned heures; unsigned minutes; double secondes; };
int main()
{
struct temps t1, t2;
printf("Première mesure (hh:mm:ss) : ");
if (scanf("%u:%u:%lf", &t1.heures, &t1.minutes, &t1.secondes) != 3)
{ printf("Mauvaise saisie\n"); return 1; }

printf("Deuxième mesure (hh:mm:ss) : ");

if (scanf("%u:%u:%lf", &t2.heures, &t2.minutes, &t2.secondes) != 3)
{ printf("Mauvaise saisie\n"); return 1; }

printf("Il y a %.3f seconde(s) de différence.\n",

(t2.secondes+60*(t2.minutes+60*t2.heures))-
(t1.secondes+60*(t1.minutes+60*t1.heures)));
return 0; 32
}
10/10/2024