Préliminaires

Université Assane SECK de Ziguinchor

Unité de Formation et de Recherche

des Sciences et Technologies

Département d’Informatique

Les structures de
données complexes
et statiques

Février 2016

Guy MBATCHOU
 Préliminaires

Préliminaires

1.1 - Durée : 21 jours

1.2 - Objectifs pédagogiques

 appliquer la structure de données « struct » dans la résolution des problèmes (O31) ;

 manipuler les variables de type « enum » (O32) ;

 gérer les données dans un tableau (O33) ;

 définir un pointeur et ses opérations (O34) ;

 utiliser les chaînes de caractères (O35) ;

 manipuler des tableaux et chaînes de caractères comme des pointeurs (O36) ;

 manipuler les pointeurs de fonctions (O37) ;

 gérer les données dans un fichier (O38)

1.3 - Graphe de précédences entre les objectifs

1.4 - Proposition de scénario

O31  O32  O33  O34  O35  O36  O37  O38

1.5 - Plan de la séquence

Préliminaires................................................................................................................................ i
1.1 - Durée : 21 jours ................................................................................................................ i
1.2 - Objectifs pédagogiques .................................................................................................... i

Guy MBATCHOU Page i

 Préliminaires

1.3 - Graphe de précédences entre les objectifs ....................................................................... i

1.4 - Proposition de scénario .................................................................................................... i
1.5 - Plan de la séquence .......................................................................................................... i
Objectif 32 : Les enregistrements ou structures ................................................................. 1
2.1 - Durée : ............................................................................................................................. 1
2.2 - Seuil : 50% ...................................................................................................................... 1
2.3 - Ressources ....................................................................................................................... 1
2.3.1 - Définition ............................................................................................................... 1
2.3.2 - Déclaration ............................................................................................................. 2
2.3.3 - Déclaration d’une variable ..................................................................................... 2
2.3.4 - Utilisation ............................................................................................................... 2
2.3.5 - Transmission d’une structure en argument ............................................................ 3
2.3.6 - Les alias de types ................................................................................................... 3
2.4 - Activités .......................................................................................................................... 4
Objectif 33 : Les énumérations .......................................................................................... 6
3.1 - Durée : ............................................................................................................................. 6
3.2 - Seuil : 30% ...................................................................................................................... 6
3.3 - Ressources ....................................................................................................................... 6
3.4 - Activités .......................................................................................................................... 7
Objectif 34 : Les tableaux .................................................................................................. 8
4.1 - Durée : ............................................................................................................................. 8
4.2 - Seuil : 60% ...................................................................................................................... 8
4.3 - Ressources ....................................................................................................................... 8
4.4 - Activités ........................................................................................................................ 10
Objectif 35 : Les chaînes de caractères ............................................................................ 11
5.1 - Durée : ........................................................................................................................... 11
5.2 - Seuil : 60% .................................................................................................................... 11
5.3 - Ressources ..................................................................................................................... 11
5.3.1 - Déclaration ........................................................................................................... 11

Guy MBATCHOU Page ii

 Préliminaires

5.3.2 - Initialisation ......................................................................................................... 11

5.3.3 - Lecture / Ecriture ................................................................................................. 12
5.3.4 - Quelques fonctions des chaînes de caractères...................................................... 12
5.4 - Activités ........................................................................................................................ 13
Objectif 36 : Les pointeurs et ses opérations.................................................................... 15
6.1 - Durée : ........................................................................................................................... 15
6.2 - Seuil : 90% .................................................................................................................... 15
6.3 - Ressources ..................................................................................................................... 15
6.3.1 - Notion d'adresse ................................................................................................... 15
6.3.2 - Notion de pointeur ............................................................................................... 15
6.3.3 - Déréférencement, indirection ............................................................................... 16
6.3.4 - Pointeurs constants............................................................................................... 17
6.3.5 - Arithmétique des pointeurs .................................................................................. 18
6.4 - Activités ........................................................................................................................ 19
Objectif 37 : Manipulation des tableaux et chaînes de caractères comme des pointeurs. 20
7.1 - Durée : ........................................................................................................................... 20
7.2 - Seuil : 90% .................................................................................................................... 20
7.3 - Ressources ..................................................................................................................... 20
7.3.1 - Utilisation des pointeurs avec les tableaux .......................................................... 20
7.3.2 - Les chaînes de caractères : pointeurs et tableaux à la fois ! ................................. 21
7.4 - Activités ........................................................................................................................ 22
Objectif 38 : Les pointeurs de fonctions .......................................................................... 23
8.1 - Durée : ........................................................................................................................... 23
8.2 - Seuil : 90% .................................................................................................................... 23
8.3 - Ressources ..................................................................................................................... 23
8.3.1 - Déclaration de pointeurs de fonctions .................................................................. 23
8.3.2 - Affectation d’une fonction à un pointeur de fonction .......................................... 24
8.3.3 - Fonction transmise en argument .......................................................................... 26
8.4 - Activités ........................................................................................................................ 26

Guy MBATCHOU Page iii

 Préliminaires

Objectif 39 : Les fichiers .................................................................................................. 27

9.1 - Durée : ........................................................................................................................... 27
9.2 - Seuil : 90% .................................................................................................................... 27
9.3 - Ressources ..................................................................................................................... 27
9.3.1 - Introduction .......................................................................................................... 27
9.3.2 - Déclaration d’un fichier ....................................................................................... 27
9.3.3 - Ouverture d’un fichier.......................................................................................... 28
9.3.4 - Fermeture d’un fichier ......................................................................................... 29
9.3.5 - Accès aux données ............................................................................................... 29
9.3.5.1 - Lecture ........................................................................................................... 29
9.3.5.2 - Écriture ........................................................................................................... 30
9.3.5.3 - Accès direct aux données d’un fichier ........................................................... 30
9.3.6 - Quelques fonctions............................................................................................... 31
9.3.7 - Exemple d’écriture et lecture d’un fichier binaire de livres................................. 32
9.4 - Activités ........................................................................................................................ 34
Activités à objectifs multiples .................................................................................................. 35
Récapitulatif des activités par objectifs .................................................................................... 36

Guy MBATCHOU Page iv

 Objectif 31 : Les enregistrements ou structures

Objectif 31 : Les enregistrements ou structures

1.1 - Durée :

1.2 - Seuil : 50%

1.3 - Ressources
Soit un programme où il est question de sauvegarder (stocker dans des variables) les
informations sur un étudiant. Pour simplifier, nous nous intéressons aux caractéristiques
suivantes d’un étudiant : nom, prénom, âge, sexe, niveau et filière d’études. Pour stocker donc
un étudiant, nous aurons besoin six (06) variables correspondant aux six caractéristiques d’un
étudiant : 3 variables de type chaîne de caractères pour le nom, prénom et filière d’études ; 2
variables de type entier pour l’âge et le niveau d’études ; 1 variable de type caractère pour le
sexe.
La difficulté vient du fait que d’une part pour déclarer un étudiant, il faut beaucoup de
variables (proportionnelles aux caractéristiques) et d’autre part, il est possible de se tromper
lors de la manipulation des variables et associer par exemple le nom d’un étudiant au prénom
d’un autre.
Pour résoudre ces problèmes, il serait intéressant d’avoir une structure permettant
d’encapsuler (englober) toutes les caractéristiques en un seul bloc indivisible. En algorithmique,
cette structure existe et s’appelle les enregistrements. En langage C, elle s’appelle struct.

1.3.1 - Définition
Un enregistrement est une structure de données composée de caractéristiques pouvant
être de type différent.
Un enregistrement est utilisé si et seulement si l’information a au moins deux (02)
caractéristiques.

Donner des exemples de données déclarables par des structures

Guy MBATCHOU Page 1

 Objectif 31 : Les enregistrements ou structures

1.3.2 - Déclaration
struct nomStructure {
type1 champ1 ;
type1 champ1 ;
…
type1 champN ;
};
struct est le mot clé qui permet de déclarer une structure dont le nom est nomStructure
contenant plusieurs champs avec leur type respectif.
Un champ de la structure peut être de type simple (char, int, float, double) ou de type
structure ou un autre type complexe comme un tableau.
L’ordre des champs ou caractéristiques est laissé à l’appréciation du programmeur.
Vous pouvez décider de regrouper les caractéristiques par type ou par sémantique ou par ordre
alphabétique ou selon des critères propres à vous. L’ordre des caractéristiques importe peu !

Donner la déclaration des types de données des exemples cités ci-

dessus

1.3.3 - Déclaration d’une variable

La déclaration d’une variable de type structure se fait soit en :
 en faisant suivre la définition de la structure par l’identificateur (ou nom) de la
variable
struct Nombre_Complexe {
double partie_en ;
double partie_im ;
} nombre1, nombre2 ;
 en précédent les identificateurs des variables par le mot clé struct suivi du nom
de la structure
struct Nombre_Complexe {
double partie_en ;
double partie_im ;
};

struct Nombre_Complexe nombre1, nombre2 ;

1.3.4 - Utilisation
L’accès à un champ de la variable de type structure se fait en suivant le nom de la
variable par l’opérateur point « . » et du nom du champ.

Guy MBATCHOU Page 2

 Objectif 31 : Les enregistrements ou structures

Exemple :
nombre1.partie_en = 10 ;
Lors de la manipulation des structures, vous devez le faire champ par champ car :

 les champs peuvent être de type différent ;

 même si les champs sont de même type, leur manipulation groupée (non champ par
champ) peut être sémantiquement incorrecte. Par exemple l’instruction nombre1 +
nombre2 est incorrecte car c’est à vous de programmer l’addition de 2 nombres
complexes en additionnant les parties réelles (nombre1.partie_en + nombre2.partie_en)
entres elles et les parties imaginaires (nombre1.partie_im + nombre2.partie_im) entres
elles.
Par contre, il est possible d’affecter à une variable de type structure une autre variable
de même type.
Au lieu d’écrire :
nombre1.partie_en = nombre2.partie_en ;
nombre1.partie_im = nombre2.partie_im ;
on peut écrire :
nombre1 = nombre2 ;

1.3.5 - Transmission d’une structure en argument

Nous avons vu précédemment que les paramètres en C ne sont transmis que par valeur
et que si dans une fonction, nous désirons modifier la valeur d’une variable, il faut transmettre
plutôt l’adresse de la variable. Il en sera de même pour les structures.
void init(struct Nombre_Complexe * c1) ;
Soit la fonction ci-dessus prenant en argument un pointeur sur un Nombre_Complexe
(ou l’adresse de la variable contenant un Nombre_Complexe), dans cette fonction, l’accès à un
champ de la structure ne peut plus se faire via l’opérateur « . » car cet opérateur suppose que le
premier opérande est une structure et non l’adresse ou le pointeur sur une structure. Pour avoir
accès à un champ, on peut soit utiliser l’opérateur « -> » (c1 -> partie_en) soit utiliser
l’opérateur « . » de la façon suivante ((*c1).partie_en).

1.3.6 - Les alias de types

Il est possible en C de nommer ou donner des alias ou des synonymes à nos types
complexes de données. Cela est possible par le mot clé typedef répondant à la syntaxe suivante :

Guy MBATCHOU Page 3

 Objectif 31 : Les enregistrements ou structures

typedef definition_type_complexe alias ;

definition_type_complexe est la définition du type complexe.
alias est le nom que nous donnons à notre type complexe.
Exemple pour types simples
typedef unsigned short int MonEntier ;

MonEntier y, z ;

Exemple pour les structures de données

typedef struct Complex_Number{
double partie_en ;
double partie_im ;
} Nombre_Complexe ;

Nombre_Complexe n1, n2 ;
Struct Complex_Number n1,n2 ;

1.4 - Activités
Exercice 01 : Poids : 100% - Seuil de validation : 80% Titre : QCM
Exercice 02 : Poids : 100% - Seuil de validation : 80% Titre : Equation du
second degré dans C
Exercice 03 : Poids : 100% - Seuil de validation : 80% Titre : Nombre complexe
MENU
1. Argument
2. Module
3. Conjuguée
4. Addition
5. Soustraction
6. Multiplication
7. Division
0. Quitter

Faites votre choix :

Exercice 04 : Poids : 100% - Seuil de validation : 80% Titre : Nombre
fractionnaire

Guy MBATCHOU Page 4

 Objectif 31 : Les enregistrements ou structures

Un nombre fractionnaire s’écrit sous la forme « a/b » où « a » est le numérateur et « b »

le dénominateur avec les contraintes « b≠0 » ; (a,b)IN²

Proposer une structure de données pour stocker un nombre fractionnaire puis réaliser le
programme correspondant au menu ci-dessous.

Nombres Fractionnaires
1- Arithmétique avec un entier
2- Arithmétique avec des fractions
3- Puissance
4- Inverse
5- Simplification

0- Quitter
Votre choix :

Lorsque le choix 1 est fait, le sous-menu « Arithmétique Fraction – Entier » est

présenté. Si c’est le choix 2, le sous-menu « Arithmétique Fraction – Fraction » est affiché.
Lorsqu’on décide de sortir d’un sous-menu, c’est le menu principal qui sera affiché et non
quitter le programme

Arithmétique Fraction - Entier

1- Addition
2- Soustraction
3- Multiplication
4- Division

0- Quitter
Votre choix :

Arithmétique Fraction - Fraction

1- Addition
2- Soustraction
3- Multiplication
4- Division

0- Quitter
Votre choix :

Guy MBATCHOU Page 5

 Objectif 32 : Les énumérations

Objectif 32 : Les énumérations

2.1 - Durée :

2.2 - Seuil : 30%

2.3 - Ressources
Les énumérations sont des cas particuliers des entiers dans lesquels chaque valeur
dispose d’un nom unique. Leur utilisation permet de définir les constantes entières dans un
programme et de les nommer.
enum nomEnumeration {nom1 [=valeur1] [, nom2 [=valeur2] [...]]};
nomEnumeration est le nom du nouveau type défini qui est un enum ;
nom1, nom2, … représentent les noms des différents énumérations.
A chaque nom, on peut associer si l’on veut une valeur entière. Au cas où ce n’est pas
fait, les énumérés reçoivent les valeurs 0, 1, … c’est-à-dire 0 pour le premier énuméré, 1 pour
le second, ainsi de suite.
Exemple : Enumération sans valeur définie
enum couleur {blanc, rouge, vert, bleu, noir} ;
Dans cet exemple, blanc a la valeur 0, rouge la valeur 1, vert la valeur 2, bleu la valeur
3 et noir la valeur 4.
Soient 2 variables c1 et c2 de type enum couleur. On peut effectuer les opérations
suivantes :
enum couleur c1, c2 ;
int a = 4 ;
c1 = bleu ; //équivalent à c1 = 3
c1 = 0 ; // équivalent à c1 = blanc
c1 = c2 ;
c1 = (3 * b) + c2 ;
n = noir + rouge ;
Les énumérations sont traitées comme des entiers et peuvent être affectées aux variables
de type entier et peuvent aussi en recevoir des valeurs venant des variables de type entier. On
peut également affecter à une variable de type enum la valeur d’une autre variable de type enum
différent
Exemple : Enumération avec valeur définie

Guy MBATCHOU Page 6

 Objectif 32 : Les énumérations

enum continent {Afrique = 4, Amerique, Asie=9, Europe, Oceanie} ;

Afrique aura la valeur 4 et non 0 car 4 lui a été affecté dans la déclaration, Amerique
aura la valeur 5, Asie n’aura pas 6 mais 9, Europe aura 10 et Oceanie la valeur 11.
Il est possible que 2 noms différents au sein d’une même énumération puissent avoir la
même valeur.
enum pays {Senegal=5, Mali, Burkina, Guinee=4, Gambie, Nigeria} ;
Dans l’exemple ci-dessus, vous constaterez que Senegal et Gambie ont la même valeur
qui est 5. Senegal = 5, Mali = 6, Burkina = 7, Guinee = 4, Gambie = 5, Nigeria = 6.
Les valeurs des énumérations peuvent être négatives.
Dans deux énumérations différentes, on ne peut pas avoir deux noms identiques.
enum region {Ziguinchor, Kolda, Sedhiou, Dakar};
enum departement {Bignona, Goudomp, Ziguinchor} ; // Erreur car Ziguinchor est déjà défini
int Dakar ; // Erreur car Dakar est déjà défini

Utilisation de l’alias
typedef enum color {blanc, rouge, vert, bleu, noir} Couleur ;
enum color a, b ;
Couleur c, d ;

2.4 - Activités
Exercice 05 : Poids : 40% - Seuil de validation : 60% - Titre :
Ecrire un programme qui

Guy MBATCHOU Page 7