Compétences et connaissances visées

 De traduire un algorithme en langage C

Programmation en C  De respecter la syntaxe du langage C.

 Définir les structures de données simples pour la résolution
d’un problème
TSOPZE N.  Programmer les fonctions et les utiliser dans un programme
tsopze@uy1.uninet.cm principal

Nombre de séances de CM : 10
Durée de la séance de CM : 02H00

Structure Structure
#include <stdio.h> // declaration des fichiers d’en-tête  Importation des bibliothèques
#include<stdio.h>
//Décalaration des constantes #include<conio.h>
// déclaration des types et fonctions  Déclaration des constantes
#define nom_cte val
//déclarations des variables globales
nom_cte est le nom utilisé pour le désigner dans le programme et val sa valeur fixée
int main()// Début du programme principal Exemple : #define DEUX 5
{
Corps du programme
// Déclaration des variables
int main ( )
printf("Hello, world\n"); {
return 0 printf ( "Bonjour à tous \n! " ) ;
getch ( ) ;
}
return 0 ;
}

1
Fonction principale (main) Fonction principale (main)
int main ( )  Commentaires
{déclaration des variables  séquence de caractères ignorée par le compilateur,

<instructions à exécuter>  Utiliser pour expliquer des portions de code

 délimiter par /* …… */ ou sur la ligne par //………
return 0 ;
exemple
}
/* Commentaire sur
 Chaque instruction se termine toujours par un point-virgule
plusieurs lignes */
 getch() ; permet de suspendre l'exécution du programme jusqu'à
ce que l'utilisateur appuie sur une touche, fonction de la // Commentaire jusqu'à la fin de ligne
bibliothèque conio.h

Préprocesseur directive #include

 Programme qui est exécuté automatiquement avant la  Doit tenir sur une seule ligne
compilation et qui transforme votre fichier source à partir  incorporer avant la compilation le texte figurant dans un
d’un certain nombre de directives. fichier quelconque
 écrites sur des lignes distinctes  #include <nom_fichier>
 introduites par un mot précis commençant par le caractère  recherche le fichier mentionné dans un emplacement défini par
#. (#include et #define). l’implémentation.
 incorporation de fichiers source (#include) ;  #include "nom_fichier’’
 définition de symboles et de macros (#define) ;  Recherche le fichier dans le même répertoire que le fichier
 compilation conditionnelle. source

2
directive # define Éléments de base
 définition de symboles ; #define remplacé remplaçant  Type
 substituer « rempacé » par « remplaçant » dans le fichier source  Variables
 #define entier int permet de remplacer le mot « entier » par  Opérateurs
« int » dans le texte.
 expressions
 #define bonjour printf("bonjour")
 définition de macros.
 définition des symboles avec des paramètres
 #define carre(a) a*a

identificateur Variables
 Utiliser pour désigner les différents objets manipulés par  porte un nom permettant de l’identifier.
le programme : variables, fonctions, etc  toujours la déclarer avant toute utilisation.
 peut se faire n’importe où dans le programme,
 formés d’une suite de caractères choisis parmi les
 n’est visible (accessible) que partout dans les accolades qui
lettres ou les chiffres, dont le premier est toujours entourent cette déclaration.
une lettre.  Possibilité de l’initialiser à la déclaration
 caractère souligné (_) est considéré comme une lettre  syntaxe de déclaration :
 Sensibilité à la casse : majuscules différentes des <Type> <liste des variables> ;
minuscules <type> var1=val1, var2=val2…;
 Mots-clés: réservés par le langage à un usage bien int a, i=0;
défini, ne doivent pas être utilisés comme char c1,c2;
const int n = 20 ; // n est une variable mais sa valeur ne doit pas changer
identificateur

3
Instructions de base Instructions de base
 Saisie des valeurs : récupérer les valeurs saisies par un  Affectation
utilisateur et la placer dans une variable var, on utilise la  se fait avec le symbole = (variable (lvalue)= expression;) →
Expression est évaluée est sa valeur sauvegardée dans variable.
fonction suivante :
 peut se aussi se faire k = i = 5  (k= (i=5);
scanf ( "%descripteur" , &var);
 Le programme attend jusqu'à ce que l'utilisateur ait saisi une
 Affichage
valeur et valide. La valeur saisie est alors affectée à la variable  Pour afficher le contenu d’une variable à l’écran, on utilise la
<variable>. fonction :
 Variable toujours précédée par &. printf ( "%descripteur" , <variable >);
 Les caractères spéciaux :
 Fin de ligne : \n
 Tabulation : \t

Types de données Types de données

 Entier  Réel
 short %hd  Float : simple précision
 int %d  double : double précision
 long %ld  long double : précision égale au moins à double
 Le caractère de séparation est « . »
 Entiers non signés
 Format:
 unsigned short %hu  Notation décimale : %f
 Unsigned int %u  Notation exponentielle : %e
 Unsigned long %lu
 nombre exponentiel : « nombre »«e »«entier » . Ex: 2.75e-2

4
 Types de données Opérateurs
 Caractères  arité 1 (opérateur unaire) ;
 type char;
 Arité 2 (opérateur binaire);
 représenter le code ASCII d'un caractère, il est donc codé sur 1 octet.
 descripteur d’un char :%c.  Arité 3 (opérateur ternaire)
Affectation
char a ;
a=‘T’; // Affectation du caractère T à la variable a
Un opérateur peut être:
Constantes  préfixé (opération avant l’opérande)
 valeur portant un nom, pas modifiables.  postfixé (opérateur près opérande)
 définit dans l'entête de la source, avec #include.
#define <NOM CONSTANTE> <valeurConstante>,
Utiliser la fonction sizeof(x) pour connaitre la taille de x en nombre d’octets.

Opérateurs unaires Opérateurs binaires

 priorité équivalente;  Opérations logiques
 parenthésage implicite de droite à gauche,  opérateur & : ET de deux représentations
opérateurs associatifs à droite. binaires.
 Opposée : –x.  opérateur | : OU de deux représentations
 Complément binaire : ~x ; binaires.
 complémente bit à bit l’opérande x.  opérateur ^ : OU exclusif de représentations
 Cast : (type)  opérateurs de décalage de priorité équivalente :
 convertir une variable à un type compatible
>>, << ; les autres opérateurs de priorité
inférieure
 Exemple: (int)x

5
Opérateurs binaires Opérateurs binaires
 décalage de bits à droite : a >> n  multiplication: *
 effectue n décalages des bits de la  Division: /
représentation binaire de a vers la droite.  Modulo: %
 décalage de bits à gauche: a << n  Addition: +
 effectue n décalage des bits de la représentation  Soustraction :-
binaire de a vers la gauche.
 Multiplication et division sont prioritaires sur
l’addition et la différence

Formes contractées Formes contractées

 Unaires Avant après
 incrémenter (augmenter de 1) une variable i a=a+b a += b
 postfixé: i++, a=a–b a -= b
 Préfixé: ++i.
 décrémenter (diminuer de 1) i
a=a*b a *= b
 i-- (forme postfixe), a=a/b a /= b
 --i (forme préfixe). a=a%b a %= b
 Binaires
a=a&b a &= b
variable = variable operateurBinaire expression est:
variable operateurBinaire= expression. a=a^b a ^= b
a=a|b a |= b

6
Opérateurs ternaire Opérateurs séquentiels
<variable> = (<condition >) ? <valeur si  exprimer plusieurs calculs successifs au sein d’une même
vrai> : < valeur si faux> ; expression.
 a * b , i + j // d’abord a*b puis i+j
 Valeur si vrai: valeur que variable prend si la
 i++, j = i + k // ……………………
condition est VRAI  associativité de gauche à droite
 Valeur si faux : valeur que variable prend si la  i++, j = i+k, j-- //………………
condition est FAUX
 condition : expression booléenne
Exemple: affecter à x le maximum de a et b
x= (a>=b)? a:b;
x=a==b?x:y  attention à la priorité

Opérateurs (ordre de priorité)

Opérateurs (ordre de priorité)
1. opérateurs unaires + et –
2. opérateurs *, / et %.
3. opérateurs binaires + et -.
 En cas de priorités identiques, les calculs
s’effectuent de gauche à droite.
 associativité de gauche à droite
 Utiliser les parenthèses pour imposer une
priorité
Programmer en langage C, C. Delanoy

7
 Conversion implicite Instructions composées
1. Que faire quand on additionne un « int » et
un « float » par exemple?
2. Le type ayant la plus grande représentation
 Traitements conditionnels
(nombre de bits) domine
int -> long -> float -> double -> long double  Instructions répétitives
Exemple
int n; long p; float x
n * p + x est un float

Traitements conditionnels Traitements conditionnels

 Si ... Alors  Si ... Alors ... Sinon
i f (<condition >)
{ if (<condition >)
<Bloc instructions > {
} <bloc instructions 1 >
Opérateurs Définitions
}
== égalité el se
! Négation - complément {
<, <= Strictement inférieur à, inférieur ou égal à <bloc instructions 2 >
>, >= Strictement supérieur à, supérieur ou égal à }

8
 Traitements conditionnels Traitements répétitifs
 Switch
switch(<nomvariable >) Boucle pour  for
{  boucle tant que  while
case <valeur 1> : <bloc instructions 1 > ; break ;
case <valeur 2> : <bloc instructions 2 > ; break ; Répéter … jusqu’à (faire …
...
case <valeur n> : <bloc instructions n > ; break ;
tant que)  do …while
default : <Bloc instructions par défaut>
}
« break » pour sortir du switch en sautant les valeurs
suivantes

Traitements répétitifs (for) Traitements répétitifs (while)

for(<initialisation > ; <condition> ; <instruction>) while(<condition >)
{ {
<bloc instructions> <bloc instructions >
} }
 <initialisation> : donner la valeur initiale du  Évaluer la condition avant chaque passage dans la
compteur boucle,
 <condition>: condition de sortie de la boucle
 puis exécuter les instructions de la boucle si VRAI
 <instruction>: pour modifier la variable
compteur

9
 Traitements répétitifs (do…while)
do
{
Types de données structurés
<bloc instructions >
}
 Tableaux
while(<condition >);
 Évaluer la condition après chaque passage dans la  Chaines de caractères
boucle.  pointeurs
 exécuter le corps de la boucle tant que la condition  Structures
est vérifiée.
 énumérations
 Pas absolument équivalente à répéter (en algo)

tableaux tableaux
 Ensemble d’éléments (variables) de même type,  Initialisation à la déclaration
identifié par un nom.  disposer par ordre d'indice croissant en les séparant par
des virgules les éléments du tableau.
 Chaque variable du tableau numérotée, par un
<type> <nom>[<taille >] = <valeur d’initialisation >;
indice. <type> <nom>[<taille >] = {<valeur 0 >, <valeur 1 >, . . . , <valeur
 les indices commencent toujours à 0. n-1>}
 Possibilité d’ommettre la dimension
int tab[] = { 10, 20, 5, 0, 3 } ;
 Déclaration
 Accès aux éléments
<type> <nomdutableau>[<taille >] ;  accéder à l’élément d’indice i : T[i]; 0 ≤ i ≤ n-1.

10
 tableaux
 tableaux à plusieurs indices
<type> <nomdutableau>[<taille1 >][taille2]... ;
 Initialisation
<type> <nom>[<taille1 >][taille2] = {liste des valeurs};
 Possibilité de disposer les éléments ligne par ligne
entre accolades
<type> <nom>[<taille >] [ligne]= {{ligne1},{ligne2},….}
Pointeurs
 l’adresse d’une lvalue (variable): &
 manipuler des adresses à l’aide des pointeurs
int * ad ; // ad est un pointeur sur un entier
int n ; // n est un entier
n = 20 ;
ad = &n ; // variable ad la valeur de l’expression &n, ie
//l’adresse de n
*ad = 30 ; // met dans le mot dont l’adresse est dans ad, la valeur
//30, n prend la valeur 30

Pointeurs Chaînes de caractères

 int * ad ;  tableau de char se terminant un caractère nul (de code ASCII
0 et s'écrit '\0‘).
 ad + 1 // adresse de l’entier suivant.
 Pour une chaine de n caractères, il faut n+1 cases
 différence entre ad+1 et ad est ici de sizeof(int) char <nom chaine>[<taille >] ;
octets Ou encore
 double * ad2 ; char * adr;
 ad++ /*passe au double suivant, la différence est descripteur : %s
 Initialisation
sizeof(double) */
char <nom chaine>[<taille >] = <valeur_initiale>;
char ch[20] = "bonjour" ;
char ch[20] = { 'b','o','n','j','o','u','r','\0' }

11
 Chaînes de caractères Chaînes de caractères (E/S)
 Accès aux éléments  Fonctions classiques
 Par accéder à l’élément d’indice i+1 de la chaîne ch :  Utiliser scanf et printf avec pour descripteur %s
ch[i] scanf(‘’%s ’’, ch) // absence de &
 Tableau de chaine de caractères NB: la chaine se termine avec un délimiteur classique (espace,…)
 Tableau de pointeurs sur les char
 Fonctions spécifiques
char * jour[7] = { "lundi", "mardi", "mercredi", "jeudi", "vendredi",
 Lecture : fgets (<chaine >, <taille >, stdin ) ;
"samedi", "dimanche« }
gets(ch)
 Accès aux éléments
 Ecriture: puts
Jour[i]
puts (ch)
NB: seule la fin de ligne marque la fin de la chaine

bibliothèque string.h bibliothèque string.h

 strlen : longueur d'une chaîne de caractères  strcmp : comparer deux chaînes.
n=strlen(ch)
strcmp(ch1, ch2)
 strcat : concaténer deux chaînes
strcat(ch1,ch2)  positive si ch1 > ch2 ;
 Concatène ch1 et ch2, puis place le résultat dans  nulle si ch1 = ch2
ch1 négative si ch1 < ch2
 Chaine vide (pointeur nul) si strcat se passe mal
 strncat (ch1, ch2, lgmax)//
strncmp ( ch1, ch2, lgmax )
lgmax est le nombre de caractères de ch2 à prendre Limite la comparaison au lgmax premiers
dans l’opération caractères

12
 bibliothèque string.h bibliothèque string.h
strcpy ( ch1, ch2 ) : strchr ( ch, car )
recopie la chaîne ch2 dans l’emplacement  recherche, dans chaîne ch, la première position
du caractère car.
d’adresse ch1.
strrchr ( ch, car )
la taille de ch1 soit suffisante pour  recherche, dans chaîne ch, la dernière position
accueillir la chaîne ch2. du caractère car.
strncpy ( ch1, ch2, lgmax ) strstr ( ch, ss_ch )
limiter la recopie au lgmax premiers  recherche, dans chaîne ch la première
caractères. occurrence complète de la sous-chaîne ss_ch

Types composés hétérogènes Structure (enregistrement)

struct nom_enreg
Enregistrements, {
unions, type champ ;
énumérations, type champ ;
type champ ;
…….
};
 Déclaration d'une variable
struct enreg var

13
Structure (enregistrement) Structure (accès aux éléments)
exemple : un article est caractérisé par un Séparer le nom de la variable et
numéro, une quantité et un prix.
struct enreg celui du champ par un « . »
{ Nom_variable.nom_champ *
int numero ;
int qte ;
scanf(‘’%d’’,&art1.numero)
float prix ; art1.qte=0;
};
 Affectation des enregistrements
struct enreg art1, art2 ;// une déclaration de
variables art2=art1;

typedef typedef (enregistrement)

 permet de définir ce que l’on nomme en langage struct enreg
C des types synonymes. { int numero ;
 applique à tous les types et pas seulement aux int qte ;
structures. float prix ;
};
typedef int entier ; // signifie
que entier est
synonyme de int, de sorte que les déclarations
suivantes sont équivalentes : typedef struct enreg Article ; //Article devient un type
int n, p ; entier n, p ; désormais
Article art1, art2 ;

14
typedef (enregistrement) Tableaux + structures
 Un champ peut être de type tableau
typedef struct
struct personne { char nom[30] ;
{ int numero ;
char prenom [20] ;
int qte ; float heures [31] ;
float prix ; } employe, etudiant;
} Article;
Article devient désormais un type et on peut  Nom et prenom sont des tableaux de 30 caractères ;
déclarer les variables de ce type  heures qui est un tableau de 31 flottants
 Accès aux éléments:
Article art1, art2 ;
etudiant.prenom
Printf(‘’%f’’,etudiant.heures[0]);

Tableau d’enregistrement Enumérations

déclaration  cas particulier de type entier défini par le programmeur
 Déclaration
struct point { char nom ;
enum nom_type {valeur1,valeur2,…}
int x ;  Exemple
int y ; enum diplome {bacc, licence, master, doctorat}
};  Déclaration de variables
struct point courbe [50] ; enum diplome d1, d2;
d1=bacc;
d2=licence
Accès aux éléments : courbe[i].x=0; d3=d1

15
pointeur Pointeur et tableau
 manipulation des adresses par l’intermédiaire de
variables int t[10];
t est équivalente à &t[0].
 nom_type * variable  variable est un pointeur sur un
t est comme étant de type pointeur sur le type correspondant aux
objet de type nom_type
éléments du tableau : int *.
 *variable  accès à la valeur pointée par le pointeur
 équivalences :
variable
t+1 &t[1]
 &variable  pointeur (adresse) de la variable t+i &t[i]
int * ad ; t[i] * (t+i)
int n ;  Exemple: initialiser un tableau de 10 entiers à 1
n = 20 ; int i ;
ad = &n ; for (i=0 ; i<10 ; i++)
*ad = 30 ; * (t+i) = 1 ;

Sous – programmes (macro)

 Utiliser la directive #define
Sous - programmes  Son appel est remplacé par son code à la
compilation
Macro #define carre(a) a*a
fonctions carre(z) deviendra z*z
carre(valeur) deviendra valeur*valeur
carre(12) deviendra 12*12

16
 Sous - programmes
 scinder en plusieurs parties et de regrouper dans
le programme principal les instructions en
décrivant les enchaînements
 éviter des séquences d’instructions répétitives
 partage d’outils (fonctions)
 Deux formes:
 Procédure : aucun retour
 Fonction: retour attendu (instruction return)
NB: en C, tout sous programme est une fonction
Sous – programmes (fonctions)
 Possibilité de ne pas utiliser la valeur de
retour
Exemple: printf ou scanf
 Possibilité de ne fournir aucune valeur
(void);
 Le type de retour peut être quelconque
 Possibilité pour une fonction de modifier les
valeurs de certains de ses arguments

Sous – programmes (déclaration) Sous – programmes (définition)

 Déclaration: juste donner l’entête de la Aucun retour (procédure)
fonction (type, nom et liste des arguments) void nomprocedure (paramètres)
 Optionnelle mais toujours avant toute utilisation {
 Placée dans le fichier d’entête /*
float carre (float v) Declaration des variables locales
*/
 Définition: décrire la fonction (entête + corps)
<bloc d’instructions>
 Peut être écrite avant ou après (si déclarée) l’appel
}
Float carre (float v){ return v*v;}

17
 Sous – programmes (définition) Sous – programmes (utilisation)
Avec un retour  Doit être au moins déclarée ou définie avant tout
Type nomFonction (paramètres) appel
{ {
/* …..
Nomprocedure (paramètres)
Declaration des variables locales
type a=nomFonction(paramètres)
*/
….
<bloc d’instructions> }
Return <valeur de retour>
}

Sous – programmes (utilisation) Passage de paramètres (par valeur)

Exemple  aucune modification sur l’argument après l’appel

int double(int a){  Tout se passe comme si l’appel avait fait une copie de la
valeur de l’argument et utiliser cette copie
return 2*a;
} void permuter (int a, int b)
main()
int main() { int c ;
{ void permuter (int a, int b) ;
printf ("début echange : %d int n=10, p=20 ;
{int x=5;
%d\n", a, b) ; printf ("avant appel : %d %d\n", n, p)
printf(‘’%d’’, double(x)); c=a ;a=b;b=c; ;
… printf ("fin echange : %d permuter(n, p) ;
} %d\n", a, b) ; printf ("après appel : %d %d", n, p)
}
}

18
Passage de paramètres (par adresse) Paramètres en nombre variable
 Passer l’adresse du paramètre que son nom  Fichier à incluire #include <stdarg.h>
 Modifier sa valeur à travers son adresse en mémoire
 déclaration:
 Paramètre modifié après l’appel si la fonction l’a modifié
main() type nom_fonction(paramètres fixes,…) les
void permuter (int *a, int *b)
{ int c ; { void permuter(int a, int b) ; « … » indiquent que la partie variable des
printf ("début echange : %d int n=10, p=20 ; paramètres
%d\n", *a, *b) ; printf ("avant appel : %d %d\n",
c = *a ; *a = *b ; *b = c ; n, p) ; Cas des fonctions scanf et printf
printf ("fin echange : %d %d\n", permuter(&n, &p) ;
*a, *b) ;
}
printf ("après appel : %d %d", n,
p)
}

Paramètres en nombre variable Paramètres en nombre variable

 Deux éléments:  macros va_start et va_end pour marquer le début et la fin

 va_list adpar : #include <stdio.h>

#include <stdarg.h>
 adpar est un identificateur de liste variable, servira
void essai (int nbpar, ...)
à récupérer les différents arguments variables { va_list adpar ;
 fonction va_start permet de l’initialiser à l’adresse int parv, i ;
du paramètre variable printf ("nombre de valeurs : %d\n", nbpar) ;
va_start (adpar, nbpar) ;
 fonction va_arg : for (i=1 ; i<=nbpar ; i++)
 fournit la valeur trouvée à l’adresse courante fournie { parv = va_arg (adpar, int) ;
par adpar; printf ("argument variable : %d\n", parv) ;
}
 incrémente l’adresse contenue dans adpar
}

19
 Variables globales Variables locales
 Déclarées hors du bloc  Portée limitée au bloc où elles sont déclarées
 Peut-être utilisée dans n’importe quel sous programme  Aucun lien avec les variables globales de même nom
du fichier, à condition d’être déclarée avant  Variable locale statique: conserve d’un appel à l’autre;
 Permet d’échanger les données entre les sous initialisé à 0 par défaut
programmes static type nom_variable;
int i ; main()
void test(void) { for (i=1 ; i<=5 ; i++) void test_static(void)
{ printf ("%de appel\n", i) ; { static int i ;
test() ;
} i++ ;
} printf ("appel numéro : %d\n", i) ;
}

Passage des tableaux en paramètres Passage des structures en paramètres

 Nom du tableau comme paramètre est considéré  Passage par valeur
comme une adresse void affiche(struct etudiant e)
 Possibilité d’effectuer toutes les manipulations {
voulues sur ses éléments printf ("\n etudiant : %s %d", e.matricule, e.age);
}
void init_t(int t[10])
void init_t(int t[10])  Appel
{
void init_t(int * t) etudiant e1;
int i ;
void init_t(int t[]) Affiche(e1);
for (i=0 ; i<10 ; i++) t[i] =1 ;
}

20
Passage des structures en paramètres
 Passage par adresse
void init(struct etudiant * e){
e->matricule=‘’16Z002’’;
e->age=17;
Gestion dynamique de la mémoire
}
 Appel
etudiant e1;
init(&e1);
 Accès aux élément: * ou ->
(*e1).matricule ou e1->age

Gestion dynamique de la mémoire Fonction de création de l’espace

 mise en oeuvre de listes chaînées, d’arbres
binaires,…
 Créer l’espace lorsque le besoin est
 Éviter de perdre l’espace comme dans le cas des
tableaux
 Libérer l’espace dès que possible
 En-tête: #include <stdlib.h>
 Création dynamique de l’espace: malloc()
char * adr ;
adr = malloc (N) ;
for (i=0 ; i<N ; i++) *(adr+i) = 'x' ;
malloc(N) crée un espace de N octets et renvoie
l’adresse en retour dans un pointeur

21
Fonction de création de l’espace Libération de l’espace
 Syntaxe: void * malloc (size_t taille)  pouvoir récupérer des emplacements dont on n’a plus
besoin.
 Précision de la taille des éléments
 libérer un emplacement préalablement alloué.
Fonction sizeof()
 Fonction : free
long * adr ; free(adr)
adr = malloc (100 * sizeof(long)) ; Libère l’espace réservé à adr

Autres fonctions Liste chainée

 void * calloc ( size_t nb_blocs, size_t taille ) #include <stdio.h>
#include <stdlib.h>
allouer l’emplacement nécessaire à nb_blocs consécutifs,
ayant chacun une taille de taille octets. struct element { int num ;
float x ;
float y ;
 void * realloc (void * pointeur, size_t taille ) (stdlib.h) struct element * suivant ;
permet de modifier la taille d’une zone préalablement };
allouée (par malloc, calloc ou realloc). void creation (struct element * *
adeb) ;
main() {
struct element * debut ;
creation (&debut) ;}
void creation (struct element * * adeb)
{int num ;
float x, y ;
struct element * courant ;
* adeb = NULL ;
while ( printf("numéro x y : "),
scanf ("%d %f %f", &num, &x, &y), num)
{ courant = (struct element *) malloc
(sizeof(struct element)) ;
courant -> num = num ;
courant -> x = x ;
courant -> y = y ;
courant -> suivant = * adeb ;
* adeb = courant ;
}}

22
 Fichiers
 Déclaration
FILE * nom_fichier;
 Ouverture  lier le nom logique (utilisé dans le
programme au nom physique (vu dans l’explorateur)
Fichiers
nom_fichier = fopen (chemin, « mode") ;
 chemin: emplacement du fichier
 mode: comment ouvrir le fichier
 En lecture: r
 En écriture : w
 En ajout: a
…

Fichiers (écriture) Fichiers (écriture)

 fwrite (&var, sizeof(type de var), nb_blocs, nom_fichier) ; char nomfich[21] ;
int n ;
 &var : adresse d’un bloc d’informations à écrire ;
FILE * F;//………………………………………………………
 sizeof(typede var) : taille d’un bloc, en octets printf ("nom du fichier à créer : ") ;
 Nb_blocs : nombre de blocs de cette taille que l’on souhaite scanf ("%20s", nomfich) ;
transférer dans le fichier; F= fopen (nomfich, "w") ;//…………………………………
 nom_fichier : adresse de la structure décrivant le fichier. do { printf ("donnez un entier : ") ;
scanf ("%d", &n) ;
if (n) fwrite (&n, sizeof(int), 1, F)
;………………………………………
}
while (n) ;
fclose (F) ;

23
 Fichiers (lecture) Fichiers (lecture)
 fread (&var, sizeof(type de var), nb_blocs, Lecture et affichage du contenu du fichier F
nom_fichier) ; do
 &var : adresse d’un bloc d’informations à écrire ;
 sizeof(typede var) : taille d’un bloc, en octets
{ fread (&n, sizeof(int), 1, F) ;
 Nb_blocs : nombre de blocs de cette taille que l’on if ( !feof(F) ) printf ("\n%d", n) ;
souhaite transférer dans le fichier;
}
 nom_fichier : adresse de la structure décrivant le fichier.
 feof (F) : fin du fichier F, plus de données à lire
while ( !feof(F) ) ;

Fichiers (prédifinis)
 stdin : unité d’entrée (par défaut, le clavier) ;
 stdout : unité de sortie (par défaut, l’écran) ;
 stderr : unité d’affichage des messages
d’erreurs (par défaut, l’écran).
 stdaux : unité auxiliaire ;
 stdprt : imprimante

24