Chapitre 5 Les types personnalisés
Chapitre 5
Les types personnalisés
Ce chapitre est une suite du chapitre précédent concernant les types de données complexes, nous
avons présenté le type tableau dans ces différents formats : tableau à une dimension, tableau à
deux dimension(matrice) et les chaînes de caractères. Dans ce chapitre nous allons présenter des
types personnalisés.
1. Structures (enregistrements)
Les tableauxrecueillent des éléments de même nature. Mais il peut advenir qu’il faille regrouper
des données de natures différentes. Dans le fichier des clients d’une entreprise, par exemple, on
ne range pas que le nom du client, mais également d’autres données comme l’adresse, le chiffre
d’affaire, etc. ces données sont de différents type, théoriquement on pourrait créer des variables
distinctes pour ces données. Par exemple :
En algorithme En C
Variable int cp ;
cp : entier float ca ;
ca : réel char nom[20], ville[20] ;
nom, ville : chaîne de caractère
Mais comme données constituent une même entité et se réfèrent toutes à une seule personne.
Comme les tableaux, on rassemble ces données sous un seul nom de variable ; en C, le type de
cette variable qui est composée de plusieurs éléments de types différents est réalisé à l’aide des
structures.
Alors, les variables de type structure sont des données constituées d’un certain nombre d’autres
objets, qui sont également des variables. Ces variables partielles composants une structure sont
appelées champs de la structure.
1.1. Déclaration de la structure : la déclaration d’une structure se fait avant la déclaration des
variables
En algorithme En C
structure client struct client
cp : entier {
ca : réel int cp ;
nom, ville : chaîne de caractère float ca ;
Fin structure char nom[20], ville[20] ;
variable };
….. …..
1.2. Définition de la variable structurée
Après la déclaration de la structure nous pouvons l’utiliser comme montre l’exemple suivant :
En algorithme En C
structure client struct client
cp : entier {
ca : réel int cp ;
nom, ville : chaîne de caractère float ca ;
35
Chapitre 5 Les types personnalisés
Fin structure char nom[20], ville[20] ;
variable };
c1 : structure client ou struct client c1 ;
c1 : client
Remarques :
1. Le type d’un champ ne doit pas être celui de la structure dans laquelle le champ est contenu.
struct client
{
int cp ;
float ca ;
char nom[20], ville[20] ;
struct client c ; Erreur
};
2. Il est permis de prendre comme champ une structure d’un autre type après sa déclaration et
ce qu’on appelle imbrication des structures.
struct time
{
int heure ;
int minute ;
};
La définition d’une autre structure :
struct RDV
{
char nom[20] ;
char jour[11]
struct time horaire ;
};
3. La déclaration d’une structure et la définition d’une variable du type concerné peuvent être
condensées dans une même instruction.
En C
struct client
{
int cp ;
float ca ;
char nom[20], ville[20] ;
} c1 ; variable du type struct client
4. On peut définir en un seul coup plusieurs variables structurées.
Exemple 1 Exemple 2
struct client struct client
{ {
int cp ; int cp ;
float ca ; float ca ;
char nom[20], ville[20] ; char nom[20], ville[20] ;
}; } c1, c2, c3, …, cn ;
struct client c1, c2, c3, …, cn ;
36
Chapitre 5 Les types personnalisés
1.3. Représentation d’une structure (enregistrement)
Les structures sont composées de plusieurs zones de données, correspondant auxchamps.
Exemple :
C1
[Link] [Link] [Link] [Link]
C1
[Link] [Link] [Link] [Link]
La manipulation d'une structure se fait au travers de « ses champs ». Comme pour les tableaux, il
n'est pas possible de manipuler une structure globalement, sauf pour affecter une structure à une
autre de même type.
Ex : pour afficher une structure il faut afficher tous ses champs un par un.
Alors que les éléments d'un tableau sont accessibles au travers de leur indice, les champs d'une
structure sont accessibles à travers leur nom, grâce à l'opérateur '.‘ .
Illustration : nom_structure .nom_champ, représente la valeur mémorisée dans le champ de la
structure.
Exemple :
Pour accéder au nom de la variable c1, on utilise l'expression : « [Link] »
1.4. Opérations sur les variables structurées
1) Affectation : Il nous faut ici un opérateur spécifique : l’opérateur .
L’opérateur de champ est placé entre le nom de la variable structurée et celui du champ
concerné. La syntaxe de l’affectation a donc la forme suivante :
<nom_variable_structurée>.<[Link]>.
Exp : [Link] = ‘zerrouk’ ; [Link] = ‘Batna’ ; [Link] = 05800 ; [Link] = 23.12 ;
[Link] = 23.12+1 ; [Link]++ ;
2) Affectation entre champs de structure : on peut affecter des valeurs de champs d’une
structure à d’autres champs de la même variable structurée, ou d’autres variables structurées.
Exp : [Link] = [Link] ;
1.5. Tableaux de structures
Il arrive souvent que l’on veuille traiter non pas un seul enregistrement (structure) mais plusieurs.
Par exemple, on veut pouvoir traiter un groupe de clients. On ne va donc pas créer autant de
variables du type client qu’il y a de clients. On va créer un tableau regroupant toutes les clients du
groupe.
Il s’agit alors d’un tableau de structures (d’enregistrements).
struct client
{
int cp ;
float ca ;
char nom[20], ville[20] ;
};
37
Chapitre 5 Les types personnalisés
En algorithme En C
Var struct client T[100] ;
T : tableau de [1..100] structure client
− Chaque élément du tableau est une structure, contenant plusieurs variables de type différent.
− On accède à une structure par son indice dans le tableau.
− T[4] représente le quatrième client du tableau T
− T[4].nom représente le nom du quatrième client du tableau type.
Structure membre d’une autre structure
Une structure peut figurer parmi les champs d'une autre structure. Dans ce cas, elle doit être
déclarée avant la structure qui la contient.
Exemple :
Structure Date
jour, mois, annee : entier
Finstructure
structure client
cp : entier
ca : réel
nom, ville : chaîne de caractère
DN : structure Date
Finstructure
Lorsqu'un champ d'une structure est lui-même une structure, l’accès à ce champ se fait comme
suit : variable_structure.variable_sous_structure.champ.
Exemples :
[Link]←2022 ; lire( [Link], [Link], [Link]) ; ecrire([Link])
Dans le cas d'un tableau, l'accès se fait comme suit :
nom_tableau[indice].variable_sous_structure.champ
Exemple :
T[1].annee←2022 ; lire( T[1].jour, T[1].mois, T[1].annee) ;
ecrire(T[1].[Link])
2. Les énumérations (Définition de types personnalisé enum)
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 : enummodele {constante-1, constante-
2,...,constante-n};
En réalité, les objets de type enum sont représentés comme des int. Les valeurs possibles
constante-1, constante-2, ..., constante-n sont codées par des entiers de 0 à n-1. Il arrive dans
certain programme de ne pas affecter de valeurs numériques aux objets du langage courant
comme les continents, les jours de la semaine, les noms des mois, … ect, mais plutôt à créer un
type spécifiquement textuel et non numérique.
38
Chapitre 5 Les types personnalisés
Exemple :
En algorithmique En C
TYPE SEMAINE= (lundi, mardi, mercredi, jeudi, enum SEMAINE
vendredi, samedi, dimanche)
{lundi, mardi, mercredi, jeudi,
TYPE COULEUR= (rouge, vert, bleu) vendredi, samedi, dimanche} ;
TYPE CONTINENT =(Afrique, Amerique, Asie, enumCOULEUR
Europe, Australie)
{rouge, vert, bleu} ;
EnumCONTINENT
{Afrique, Amerique, Asie, Europe, Australie} ;
Ensuite, par exemple, l’instruction : enum SEMAINE jours ; définit une variable jours, dont le type
est enum SEMAINE
Rq :
Comme pour les structures, avec les types énumératifs, vous pouvez combiner la définition d’une
variable avec la déclaration du type. Comme l’exemple ci-dessous :
enum SEMAINE
{lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} jours ;
3. Définition de types personnalisé typedef
Pour simplifier l’écriture des programmes, on peut affecter un nouvel identificateur à un type
composé à l’aide de typedef :
typedef type synonyme;
Par exemple :
struct client
{
int cp ;
float ca ;
char nom[20], ville[20] ;
};
typedef struct client cl ;
main()
{
cl c1 ;
}
C’est plus simple que :
main()
{
struct client c1 ;
}
Rq :
Il est possible de définir un type personnalisé en même temps qu’on déclare la structure. La déclaration :
39
Chapitre 5 Les types personnalisés
typedefstruct client
{
int cp ;
float ca ;
char nom[20], ville[20] ;
} cl;
Définit un type de structure baptisé cl qui pourra être adopté comme synonyme du type struct
client et non une variable du nom cl.
Redéfinition de type simple
Vous pouvez renommer des types simples pour attirer l’attention par exemple. typedefint
ENTIER ; définit pour le type int une autre appellation (synonyme) ENTIER afin de mieux faire
ressortir la nature de la variable définit.
Le type personnalisé est très souvent écrit en majuscules, afin de bien le distinguer des types
prédéfinis.
Dans l’exemple :
char l1[80], l2[80], l3[80], l4[80], l5[80] ;
On peut arriver par l’instruction : typedef char LIGNE[80] ; à remplacer l’instruction précédente
par l’écriture plus concise : LIGNE l1, l2, l3, l4 ;
Exercices à domicile
Exercice 1
Déclarer des types qui permettent de stocker :
1. Un étudiant caractérisé par son nom, son prénom, son numéro d’inscription, son sexe (F pour
féminin, M pour masculin), son âge et sa moyenne.
2. Un groupe est défini par : son nom, liste de ses étudiants et le nombre de ses étudiants.
3. Une section définie par : son nom, ses groupes (max 20), nombre de ses groupes, son année
d’étude, sa filière et sa spécialité.
Exercice 2
Soit une section de M groupes (M≤20) dont chaque groupe contient au maximum 35 étudiants. Ecrire un
algorithme qui permet de :
• Faire entrer la liste de tous les étudiants.
• Afficher le nom et le prénom de l’étudiant/des étudiants ayants la plus grande moyenne dans la
section.
• Remplacer chaque prénom Mohammed par Mohamed.
Compter et d’afficher le nombre d’étudiants dont l’âge est supérieur ou égal à 20 ans.
40
