STRUCTURE DE DONNEES (en C/C++)

Une structure de données est une structure logique destinée à contenir des données, afin de leur donner une
organisation permettant de simplifier leur traitement. En organisant d'une certaine manière les données, on
permet un traitement automatique de ces dernières plus efficace et rapide.

Exemple :

On peut présenter une liste d’admission des étudiants :

- par ordre alphabétique
- par date de naissance
- par ordre de mérite …
À chaque usage correspondra une structure appropriée. Les données qu’on parle ici sont soient des nombres, soient
des caractères (chaînes de caractères).

I. Rappel
1. Les types de données

Le type d'une variable indique au compilateur ce que cette variable est supposée représenter. Une variable peut
contenir un entier, une valeur réelle, un caractère, l'adresse d'une autre variable... Plus encore, étant donné que les
différents types de variables peuvent avoir des tailles en mémoire différentes, il faut alors préciser le type de
donnée, ce qui permet de connaître l'occupation mémoire (le nombre d'octets) de la donnée ainsi que sa
représentation :
 Des nombres : entiers ou réels
 Des caractères : traduit par en nombre entier pour être compris par l’ordinateur (code ASCII)

Remarque :
Il n'existe pas de type de données pour les chaînes de caractères (suite de caractères) en langage C. Pour créer une
chaîne de caractères on utilisera donc des tableaux contenant dans chacune de ses cases un caractère.

Les tableaux ci-après donnent respectivement l’équivalence en numérique des caractères et les types de donnée en
C/C++.

Type de donnée Signification Taille (en octets) Plage de valeurs acceptée

char Caractère 1 -128 à 127
2 (sur processeur 16 bits) -32 768 à 32 767
int Entier
4 (sur processeur 32 bits) -2 147 483 648 à 2 147 483 647
float Flottant (réel) 4 -3.4*10-38 à 3.4*1038
double Flottant double 8 -1.7*10-308 à 1.7*10308
 caractère<b> <b>code ASCII
TAB (Tabulation horizontale) 9
ESC (Escape, caractère d'échappement) 27
SP (Space, espace) 32
! 33
" 34
+ 43
0 48
1 49
2 50
9 57
A 65
B 66
C 67
Y 89
Z 90
[ 91
\ 92
] 93
a 97
z 122

2. Les variables
Une variable est un objet repéré par son nom, pouvant contenir des données, qui pourront être modifiées lors de
l'exécution du programme. Les variables en langage C/C++ sont typées, c'est-à-dire que les données contenues dans
celles-ci possèdent un type, ainsi elles sont donc stockées à une adresse mémoire et occupent un nombre d'octets
dépendant du type de donnée stockée.
En langage C/C++, les noms de variables peuvent être aussi long que l'on désire, toutefois le compilateur ne tiendra
compte que des 32 premiers caractères. De plus, elles doivent répondre à certains critères :
- un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un « _ » (pas par un chiffre)
- un nom de variable peut comporter des lettres, des chiffres et le caractère « _ » (les espaces ne sont pas
autorisés !)

Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui donner un nom, mais surtout un type de donnée à
stocker afin qu'un espace mémoire conforme au type de donnée qu'elle contient lui soit réservé.
Une variable se déclare de la façon suivante :
type Nom_de_la_variable;(ex : int numéro ;)

ou bien s'il y a plusieurs variables du même type :

type Nom_de_la_variable1, Nom_de_la_variable2, ...;

Pour stocker une donnée dans une variable que l'on a initialisée, il faut faire une affectation.
Nom_de_la_variable = donnée; (ex : numero = 3 ;)

Pour stocker le caractère B dans la variable que l'on a appelée Caractere, il faudra écrire :
char Caractere;
Caractere = 'B';
Ce qui signifie stocker la valeur ASCII de « B » dans la variable nommée « Caractere ».
On peut également affecter une valeur initiale à la variable lors de sa déclaration, on parle alors d'initialisation :
type Nom_de_la_variable = donnee;(ex : int numero = 3 ;)

Pour définir une constante (une valeur qui reste invariable dans tout le programme) :
const int A = 26;
const float Pi = 3.14159;

3. Les entrées-sorties conversationnelles

Dans le cadre de ce cours, nous allons utiliser les fonctions printf et scanf pour afficher des informations à l’écran ou
pour en lire au clavier. Comme elles font partie de <stdio.h>, il faut faire appel à cette bibliothèque. Cela consiste à
écrire #include<stdio.h> au tout début du programme.

 La fonction printf
Cette fonction permet :
- d’afficher les caractères tels qu’ils sont
printf("bonjour !");  bonjour !
- d'afficher la valeur d'une variable
Printf ("%f", x); (qui affiche la valeur de x en décimal)

 La fonction scanf
Cette fonction permet d'enregistrer une donnée saisie au clavier
scanf ("%d %d", &n, &p); (cette commande permet de stocker deux valeurs de type int
saisies au clavier dans respectivement n et p)
scanf ("%d %c", &n, &c) ; (stocker une valeur de type int dans n et un caractère dans c)

 Les principaux codes de conversion en printf et scanf

%c caractères
%d types int
%f ou %e types float ou double
%s chaînes de caractères

4. Les opérateurs mathématiques et les opérateurs de contrôle

a. Les opérateurs mathématiques :

Les opérateurs sont des symboles qui permettent de manipuler des variables, c'est-à-dire effectuer des opérations,
les évaluer…

 Les opérateurs de calcul : Ils permettent de modifier mathématiquement la valeur d'une variable.

Opérateur Dénomination Effet Exemple Résultat (avec x valant 7)

+ opérateur d'addition Ajoute deux valeurs x+3 10
- opérateur de soustraction Soustrait deux valeurs x-3 4
* opérateur de multiplication Multiplie deux valeurs x*3 21
/ opérateur de division Divise deux valeurs x/3 2.3333333
= opérateur d'affectation Affecte une valeur à une variable x=3 Met la valeur 3 dans la variable x
  Les opérateurs d’assignation :

Ces opérateurs permettent de simplifier des opérations telles qu’ajouter une valeur dans une variable et stocker
le résultat dans la variable. Une telle opérations s'écrirait habituellement de la façon suivante par exemple :
x=x+2 . Avec les opérateurs d'assignation il est possible d'écrire cette opération sous la forme suivante : x+=2

Opérateur Effet
+= additionne deux valeurs et stocke le résultat dans la variable (à gauche)
-= soustrait deux valeurs et stocke le résultat dans la variable
*= multiplie deux valeurs et stocke le résultat dans la variable
/= divise deux valeurs et stocke le résultat dans la variable

 Les opérateurs d'incrémentation : Ce type d'opérateur permet de facilement augmenter ou diminuer d'une
unité une variable.

Opérateur Dénomination Effet Syntaxe Résultat (avec x valant 7)

++ Incrémentation Augmente d'une unité la variable x++ 8
-- Décrémentation Diminue d'une unité la variable x-- 6

 Les opérateurs de comparaison :

Résultat (avec x valant

Opérateur Dénomination Effet Exemple
7)
==
Compare deux valeurs et vérifie Retourne 1 si x est égal à
A ne pas confondre avec le opérateur d'égalité x==3
leur égalité 3, sinon 0
signe d'affectation (=) !
Vérifie qu'une variable est
opérateur Retourne 1 si x est
< strictement inférieure à une x<3
d'infériorité stricte inférieur à 3, sinon 0
valeur
Vérifie qu'une variable est Retourne 1 si x est
opérateur
<= inférieure ou égale à une x<=3 inférieur ou égal à 3,
d'infériorité
valeur sinon 0
Vérifie qu'une variable est
opérateur de Retourne 1 si x est
> strictement supérieure à une x>3
supériorité stricte supérieur à 3, sinon 0
valeur
Vérifie qu'une variable est Retourne 1 si x est
opérateur de
>= supérieure ou égale à une x>=3 supérieur ou égal à 3,
supériorité
valeur sinon 0
opérateur de Vérifie qu'une variable est Retourne 1 si x est
!= x!=3
différence différente d'une valeur différent de 3, sinon 0

 Les opérateurs logiques : Ce type d'opérateur permet de vérifier si plusieurs conditions sont vraies.

Opérateur Dénomination Effet Syntaxe

|| OU logique Vérifie qu'une des conditions est réalisée ((condition1)||(condition2))
&& ET logique Vérifie que toutes les conditions sont réalisées ((condition1)&&(condition2))
Inverse l'état d'une variable booléenne (retourne la valeur 1
! NON logique (! condition)
si la variable vaut 0, 0 si elle vaut 1)
  Les priorités : voici donc dans l'ordre décroissant les priorités de tous les opérateurs

Remarque : associativité de gauche à droite et de droite à gauche

- L'opérateur + étant associatif de gauche à droite, l'expression x + y + z est évaluée comme (x + y) + z
- L'opérateur + étant associatif de droite à gauche. Prenons l’exemple a = b = 5 ; b est défini à la valeur 5.
Ensuite, a est défini à la valeur de b. D’où a = 5

Catégorie d'opérateurs Opérateurs Associativité

fonction, tableau,
membre de structure, () [] . -> G=>D
pointeur sur un
membre de structure
- ++ -- ! ~
opérateurs unaires * & sizeof (type)
D=>G
multiplication, division, modulo * / % G=>D
addition, soustraction + - G=>D
opérateurs binaires de décalage << >> G=>D
opérateurs relationnels < <= > >= G=>D
opérateurs de comparaison == != G=>D
et binaire & G=>D
ou exclusif binaire ^ G=>D
ou binaire | G=>D
et logique && G=>D
ou logique || G=>D
opérateur conditionnel ?: D=>G
= += -= *= /= %=
opérateurs d'affectation &= ^= |= <<= >>=
D=>G
opérateur virgule , G=>D

b. Les opérateurs de contrôles

Ce sont des instructions qui permettent de tester si une condition est vraie ou non. Ils peuvent être associés à des
structures qui se répètent suivant la réalisation de la condition, on les appelle des boucles.

 L’instruction IF et IF…ELSE

L'instruction if est la structure de test la plus basique, on la retrouve dans tous les langages (avec une syntaxe
différente...). Elle permet d'exécuter une série d'instructions si jamais une condition est réalisée. La syntaxe de cette
expression est la suivante :
if (condition réalisée)
{
instructions à exécuter
}

Remarque :
 la condition doit être entre des parenthèses
 il est possible de définir plusieurs conditions à remplir avec les opérateurs ET et OU (&& et ||)
Par exemple l'instruction suivante teste si les deux conditions sont vraies :
if ((condition1)&&(condition2))

L'instruction ci-dessous exécutera les instructions si l'une ou l'autre des deux conditions est vraie :
if ((condition1)||(condition2))
  s'il n'y a qu'une instruction, les accolades ne sont pas nécessaires...
 les instructions situées dans le bloc qui suit else sont les instructions qui seront exécutées si la ou les
conditions ne sont pas remplies

L'instruction if dans sa forme basique ne permet de tester qu'une condition, or la plupart du temps on aimerait
pouvoir choisir les instructions à exécuter en cas de non réalisation de la condition... L'expression if ... else permet
d'exécuter une autre série d'instructions en cas de non-réalisation de la condition. La syntaxe de cette expression est
la suivante :

if (condition réalisée)
{
instructions
}

else
{
autres série d'instructions
}

 L’instruction SWITCH

L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable.

switch (Variable) {
case Valeur1 :
Liste d'instructions;
break;
case Valeur2 :
Liste d'instructions;
break;
case Valeurs... :
Liste d'instructions;
break;
default:
Liste d'instructions;
}

 La boucle FOR

L'instruction for permet d'exécuter plusieurs fois la même série d'instructions.

for (compteur; condition; modification du compteur)
{
liste d'instructions;
}

Exemple :

for (i=1; i<6; i++)

{
printf("%d", i);
}
 L'instruction WHILE

L'instruction while représente un autre moyen d'exécuter plusieurs fois la même série d'instructions

while (condition réalisée)

{
liste d'instructions;
}
II. Introduction aux structures
Rappelons qu'une structure de données est une manière particulière de stocker et d’organiser des données dans un
ordinateur de façon à pouvoir être utilisées efficacement.

Avec les éléments de programmation que nous connaissons, nous sommes capables de programmer tout ce qui est
programmable. Cependant l’expérience des programmeurs a conduit à introduire d’autres notions, théoriquement
non indispensables mais facilitant nettement la pratique de la programmation. Ceci est le cas des sous-programmes ;
c’est le cas également des structures de données que nous allons étudier maintenant.

1. Les tableaux (array en anglais)

Lorsque les données sont nombreuses et de même nature, au lieu de manipuler un grand nombre de variables, il est
plus pratique de ranger ces variables dans un tableau. Il s’agit la plupart du temps de tableaux à deux dimensions
avec des lignes et des colonnes. Mais on peut aussi considérer des tableaux à une seule dimension (ce sont plutôt
des listes dans le langage courant) ou à plusieurs dimensions (plus difficilement représentables de façon graphique à
partir de la quatrième dimension).

a. Tableau à une dimension

 Notion
Un tableau à une dimension est formé d’éléments tous de même nature et repérés par un index. Il est
souvent représenté comme une suite de cases avec un index pointant sur une case.

 Syntaxe
La déclaration d’un tableau suit la syntaxe suivante :

type Nom [Entier] ;

exemple : float tab [5] ;

où : Entier : une constante entière positive qui représente le nombre maximum d'élément du tableau.
L’accès à un élément du tableau de nom "Nom" se fait en désignant cet élément de la façon suivante :

Nom [index]

où index est une expression entière positive. En langage C, comme en général en informatique et contrairement à ce
qui se passe en mathématiques, l’indexation commence à 0 (et non à 1). En langage C, comme dans la plupart des
langages informatiques, il n’y a pas de vérification pour savoir si la valeur de l’index est bien comprise entre 0 et
Entier − 1. Si on sort de l’intervalle d’indexation, on risque de récupérer des valeurs sans signification (en cas de
lecture) ou, pire, de détruire une partie du contenu de la mémoire vive (en cas d’écriture). Il faut donc être
extrêmement vigilant à l’égard de ce problème.

 Application

Les élèves d’une classe de 59 élèves ont obtenu chacun une note à un certain examen. Nous voulons déterminer
combien d’entre eux ont une note supérieure à la moyenne de la classe.
/* Programme note_1.c */
#include <stdio.h>
void main(void)
{
int i, s;
float m;
float note[59];
/* Saisie des notes */
for (i=0 ; i < 59 ; i++)
{
printf("\nQuelle est la note numero %d : ",i+1);
scanf("%f", &note[i]);
}
/* Calcul de la moyenne */
m = 0;
for (i = 0 ; i < 59 ; i++) m = m + note[i];
m = m/59;
printf("\nLa moyenne est de : %4.2f", m);
/* Calcul du nombre de notes superieures a la
* moyenne */
s = 0;
for (i = 0 ; i < 59 ; i++)
if (note[i] >= m) s = s+1;
printf("\nLe nombre de notes superieures a la");
printf("\nmoyenne de la classe est de : %d", s);
}

 Initialisation d'un tableau lors de la déclaration

On peut initialiser un tableau de façon individuelle, élément par élément, par exemple grâce à une boucle. Mais, en
langage C, on peut aussi initialiser le tableau lors de sa déclaration. On fait suivre la déclaration du tableau du signe
d’égalité puis des valeurs (qui sont des expressions constantes), séparées par des virgules et placées entre
accolades :

type Nom [Entier] = {k1, k2, ..., kEntier−1} ;

exemple : int tab[5] = {1, 34, 10, 24, 6} ;
 Les chaines de caractères comme tableaux
Le type chaîne de caractères (string en anglais) n’existe pas comme type simple en langage C. Il est émulé par
des tableaux de caractères.
Une variable chaîne de caractères se déclare comme tableau de caractères. On a, par exemple :

char nom[10] ;
pour une chaîne d’au plus neuf caractères. En effet En langage C on termine la chaîne par le caractère nul (de
numéro 0 dans le code ASCII, donc le caractère ‘\0’),
 Initiation globale des chaînes de caractères :
char nom[10] = {’P’,’a’,’u’,’l’,’\0’};

 Entrées/sorties globales
Il existe heureusement des fonctions standard pour saisir et afficher globalement les chaînes de caractères. Nous
avons déjà rencontré les fonctions printf() et scanf() avec le format %s. Le nom d’une variable chaîne de caractères
ne doit pas être précédé du symbole d’adressage dans le cas de la lecture. On a, par exemple :
char nom[10] ;
printf("Quel est votre nom ? ") ;
scanf("%s", nom) ;
printf("Bonjour %s", nom) ;

Une constante entière placée entre ‘%’ et ‘s’ permet d’indiquer le nombre maximum de caractères à saisir ou à
afficher. Les autres caractères éventuels sont perdus. On a, par exemple :
scanf("%9s", nom) ;
Remarque : La fonction scanf() lit une chaîne de caractères jusqu’au premier blanc rencontré, autrement dit elle lit
un mot. On ne peut donc pas entrer “Paul Walker” par exemple. On peut en fait paramétrer la fonction scanf(). Nous
renvoyons à la documentation pour cela.

b. Tableaux à plusieurs dimensions

 Notion
Un tableau à deux dimensions est formé d’éléments tous de même nature et repérés par deux index (et non
plus un seul). Un tableau à deux dimensions est souvent représenté par un certain nombre de lignes et de colonnes.
Un élément est repéré par son numéro de ligne et son numéro de colonne.
 Syntaxe
La notion de tableau à plusieurs dimensions n’existe pas en langage C. On l’émule en utilisant des tableaux de
tableaux. On déclare plusieurs dimensions au lieu d’une seule :
type nom[dimension1][dimension2] ... [dimension];
exemple : int tab[2][3] = {1,2,3,4,5,6};
on a :
tab[0][0] = 1, tab[0][1] = 2, tab[1][2] = 6.
Pour des raisons de lisibilité on peut aussi introduire des paires d’accolades supplémentaires :
int tab[2][3] = { {1, 2, 3 }, { 4, 5, 6} } ;

c. Pointeur et tableau
Un pointeur est une variable contenant une adresse mémoire.
En langage C, l’accès à un élément d’un tableau peut se faire classiquement par le nom du tableau accompagné d’un
index, mais aussi par un pointeur manipulé par des opérations spécifiques, comme nous allons le voir.
Considérons le tableau : int note[30] ;
On peut accéder à la première note par un indice, par exemple :
note[0] = 10 ;
mais on peut aussi utiliser un pointeur :
int *ptr ;
ptr = &note[0] ;
*ptr = 10 ;
C’est plutˆot une façon compliquée de faire mais c’est possible. Mais un des avantages est la possibilité d'une
opération (addition, soustraction) :
Pour accéder à l’élément d’indice 3 on peut continuer par : note[3] = 12 ;
mais aussi, et ceci est nouveau, par :
ptr = ptr + 3 ;
*ptr = 12 ;
La syntaxe de l’addition des pointeurs est :
pointeur1 = pointeur2 + entier ;
o`u entier désigne une expression entière. Incrémentation.- Dans le cas d’une addition de un, on peut utiliser les
abréviations usuelles du C, à savoir ptr++ ou ++ptr.
On peut utiliser de même la soustraction sur les pointeurs. Par exemple :
ptr = ptr - 2 ;
nous ramène à l’élément d’indice 1 du tableau

En langage C le nom d’un tableau, par exemple note, correspond à l’adresse de son premier élément &note[0]. Ce
n’est cependant pas un pointeur, ou plus exactement une variable pointeur. Il s’agit d’un pointeur constant dont
on ne peut pas modifier le contenu (ce n’est pas une L-value). On ne peut pas écrire, par exemple :
note = note + 2 ;
pour accéder à l’élément d’indice 2. Il faut, pour cela, passer par une variable pointeur auxiliaire :
ptr = note ;
ptr = ptr + 2 ;
ou même :
ptr = note + 2 ;
2. Les types énumérés
Nous avons vu comment utiliser la boucle for et comment indexer les tableaux en utilisant les entiers. On peut
généraliser la nature des index en utilisant ce qu’on appelle les types ordinaux. Cette possibilité n’est en fait
présente que dans peu de langages informatiques. Elle se trouve sous une forme assez sommaire, sous la seule
forme des types énumérés, en langage C.

a. Définition
Un type énuméré est un type dont on énumère, c’est-à-dire dont on donne la liste effective, les éléments de ce type.
On voit immédiatement des cas o`u cela peut être intéressant, par exemple pour traiter :
– les mois de l’année (janvier, février...) ;
– les notes de musique ;
– les noms de cartes à jouer (as, roi, dame...) ;
– les marques de voiture ;
– les indications d’état civil (célibataire, marié, divorcé...).
Bien entendu cela ne peut concerner que des types correspondants à un ensemble fini d’éléments.

b. Mise en place des types énumérés en C

La définition d’un type énuméré est très simple : on énumère les éléments de ce type, qui sont des identificateurs,
séparés par des virgules et encadrés par des accolades ouvrante et fermante. Par exemple :
{lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche}
ou :
{as, roi, dame, valet, dix, neuf, huit, sept}
Pour déclarer un tel type, on commence par le mot clé enum, suivi d’un identificateur qui sera le nom du type, suivi
de la définition proprement dite, suivie d’un point-virgule. Par exemple :
enum jour {lundi, mardi, mercredi, jeudi, vendredi,samedi, dimanche};
Pour la Déclaration d’une variable d’un type énuméré, on commence également par le mot clé enum, suivi du nom
du type, suivi du nom de la variable (ou des variables), suivi d’un point-virgule. Par exemple :
enum jour j ;
Utilisation simple d’une variable d’un type énuméré.- Pour l’instant on ne peut qu’affecter une constante (du type
donné) à une variable d’un type énuméré ou comparer une variable du type à une des valeurs du type. Par exemple :
j = dimanche ;
if (j == lundi) printf("Monday");

Le langage C considère les valeurs des types énumérés comme des constantes entières de type int, les convertissant
dans l’ordre dans lequel elles ont été énumérées lors de la déclaration à partir de 0. Ceci permet alors de travailler
comme avec des types ordinaux. Pourtant, On peut forcer un élément d’un type à prendre une valeur donnée (grâce
au signe = suivi d’une constante entière), les éléments suivants étant alors incrémentés à partir de cette valeur. Par
exemple si on déclare :
enum jour {lundi, mardi, mercredi = 20, jeudi, vendredi, samedi, dimanche} ;
alors mardi aura la valeur 1, mercredi la valeur 20 et jeudi la valeur 21.
3. Les structures
Nous continuons notre étude des structures de données qui sont prédéfinies dans la plupart des langages
informatiques. La structure de tableau permet de regrouper un certain nombre de données de même type, et de
plus le type doit être assez simple (pour l’instant). Les types structurés vont nous permettre de manipuler des
données structurées dont les types des éléments peuvent être différents. Cela correspond à la notion de masque
d’un formulaire à remplir : on demande le nom; il y a un certain nombre de cases, indiquant par là le nombre
maximum de lettres permises ; on demande l’année de naissance et on s’attend à voir un entier.

a. exemple introductif
Un répertoire réaliste comprendrait le nom, le prénom, le numéro de téléphone fixe, le numéro du mobile, le
numéro du bureau, l’adresse e-mail et bien plus. Considérons un cas très simple avec juste un nom et un numéro de
téléphone par item. (Une telle structure de données s’appelle enregistrement (en anglais record) en PASCAL et tout
simplement structure en langage C).
Précisons un peu la nature des données :
- le nom sera un mot de longueur inférieure à 29 ;
- le numéro de téléphone sera un mot de longueur inférieure à 19
Ces décisions nous permettent de considérer la fiche comme un élément du type structuré suivant :
struct item
{
char nom[30];
char tel[20];
};

b. Syntaxe
La syntaxe suit la règle suivante :
struct nom
{
type 1 champ 1 ;
type 2 champ 2 ;
-------
type n champ n ;
};
o`u nom, champ 1, ... , champ n sont des identificateurs (non utilisés pour autre chose) et type 1,... , type n
des types. Chacun des identificateurs s’appelle un champ ou un membre.

c. Déclaration des variables structurées

Pour le type structuré ci-dessus on peut déclarer une variable, disons personne, de la façon suivante :
struct item personne ;
On remarquera la nécessité de répéter le mot clé struct.
On peut ne pas donner de nom au type structuré si on déclare en même le type et les variables de ce type comme
dans l’exemple suivant :
struct
{
char nom [30];
char tel [20];
} personne;
mais ceci est `a éviter.
Une variable d’un type structuré (appelée parfois variable structurée) se déclare de la façon suivante :
struct nom var ;
o`u var est un identificateur et nom le nom d’un type structuré.

d. Accès aux champs d’une structure

Les variables d’un type structuré peuvent être manipulées globalement dans une affectation ou champ par champ.
L’accès `a un champ se fait grâce `a l’opérateur de champ ‘.’. Par exemple [Link] permet d’accéder au
champ nom de la variable structurée personne.
Continuons notre exemple. Nous voulons initialiser notre répertoire. On voudrait un programme qui permette
d’initialiser les fiches (avec le nom et le numéro de téléphone), puis d’afficher le répertoire ainsi obtenu. Nous allons
demander le nom, puis le numéro de téléphone. Nous considérerons qu’un nom commençant par ‘#’ est une valeur
sentinelle de fin d’initialisation. Notre fichier comprendra au plus 100 fiches. Voici le programme :

/* init.c */
#include <stdio.h>
#include <string.h>
struct item
{
char nom[30];
char tel[20];
};
struct item fichier[100];
int n;
char name[30];
void initialiser(void)
{
n = 0;
printf("Nom : ");
gets(name); /*lecture d'une chaîne de caractère*/
/*La fonction scanf("%s",s); ne permet pas de lire des chaînes de caractères contenant des espaces
(l'espace étant pour scanf un séparateur), tandis qu'avec gets, seul le caractère \n (newline) sert de
délimiteur.*/
while (name[0] != ’#’)
{
strcpy(fichier[n].nom,name); /*copie une chaîne de caractères d'une zone à une autre*/
printf("Numero de telephone : ");
gets(fichier[n].tel);
n++;
printf("Nom : ");
gets(name);
}
}
void afficher(void)
{
int i;
for (i = 0; i < n; i++)
printf("%30s : %20s\n", fichier[i].nom,
fichier[i].tel);
}
void main(void)
{
initialiser();
afficher();
}