Algorithme Et Programation C

Cours d’Algorithmique et Programmation en Langage C
Cours d’Algorithmique et
Programmation en Langage C
A. Yengui && A. Zouch
LAPHY1 / LGBM1 (S2)
ISBS Sfax
Première partie
Les bases de la programmation
2
Sommaire de la Partie I

Algorithme
Programme
Importance des notations
Types de base
Variable et affectation
Entrées/Sorties
Instruction
Trace d’un algorithme
Structure d’un programme C
3
Algorithme
Qu’est-ce qu’un algorithme?

Définition
Moyen d’atteindre un but en répétant un nombre fini de fois un
nombre fini d’instructions.
Donc, un algorithme se termine en un temps fini.
Le langage algorithmique choisi doit être simple, clair et précis.
Nous utiliserons un langage francisé formé d’une vingtaine de

mots réservés.
4

Algorithme
Mots réservés du langage algorithmique

Ecrire Dans DébutDéclarations
DébutFonction DébutProcédure DébutProgramme
Faire FinDéclarations FinFonction
FinPour FinProcédure FinProgramme
FinSi FinTantQue ParPasDe
Pour Retourner Lire
Si Sinon TantQue
On y ajoutera des fonctions utiles, par exemple : Alea(n), qui

fournit un entier au hasard entre 0 et n − 1, plus toutes les
fonctions mathématiques usuelles : sin(x), arccos(x),
tanh(x), log(x)...
5

C
Mots réservés du langage C (norme ANSI C99)

auto enum restrict unsigned
break extern return void
case float short volatile
char for signed while
const goto sizeof Bool
continue if static Complex
default inline struct Imaginary
do int switch
double long typedef
else register union
6

Programme
Programme et algorithme
Définition
Un programme est la traduction d’un algorithme en un langage
compilable ou interprétable par un ordinateur.
Il est souvent écrit en plusieurs parties, dont une qui pilote les
autres, le programme principal.
Un programme est destiné à l’être humain. Pour en faciliter la

lecture, il doit être correctement indenté et judicieusement
commenté (cf. annexe « programme type »).
7

Importance des notations
La présentation des programmes

On nomme indentation les retraits en débuts de ligne permettant
d’extraire rapidement la structure (le squelette) d’un programme,
la logique d’une boucle ou d’un test.
La signification de parties non triviales doit être signalée par un
commentaire :
en algorithmique, il est souligné ou commence par // :
ceci est un commentaire// en voici un autre
le C possède deux notations :
commentaire ligne : // ceci est un commentaire
commentaire bloc, il commence par /* et se termine par */
8

Types de base
Le type booléen
Ensemble de définition : B = {FAUX,VRAI}
Opérations booléennes :
Non booléen OU et ET booléens
a b A OU b A ET b
a NON(a)
FAUX FAUX FAUX FAUX
VRAI FAUX
FAUX VRAI VRAI FAUX
FAUX VRAI
VRAI FAUX VRAI FAUX
VRAI VRAI VRAI VRAI
Déclaration algorithmique : a,b : booléen
Déclaration C : bool a, b;
9

Types de base
Le type entier
Ensemble de définition : Z
Opérations sur les entiers :
n1 + n2n1 − n2n1 ∗ n2
division entière : n1/n2 (35 / 8 donne 4)
reste de la division entière : n1%n2 (35 % 8 donne 3)
Notation algorithmique : n1,n2 : entier
Notation C : int n1, n2;
10

Types de base
• short int ou short (entier sur 16 bits : - 32 768 à 32 767)

• int (entier sur 32 bits : - 2 147 483 648 à 2 147 483 647)
• long int ou long (entier sur 32 bits ou 64 bits, selon les
machines)
Chacun des 3 peut être nuancé par l’utilisation du qualificatif
unsigned pour ne représenter que des nombres positifs:
Exemple: unsigned short x; x peut aller de 0 à 65 535

pas de bit réservé pour le signe
- C accepte les constantes entière en notation décimale,
hexadécimale ou octale
11

Types de base
Le type flottant
Ensemble de définition : IR
Opérations sur les flottants :
x1 + x2 x1 − x2 x1 ∗ x2 x1/x2
toutes les opérations mathématiques usuelles : ln,
cos,arctan...
Notation algorithmique : x1,x2 : flottant (ou réel)
Notation C : float x1, x2;
12

Types de base
• Float : codé sur 4 octets avec 1 bit de signe, 23 bits de

mantisse et 8 bits d'exposant
• Double : codé sur 8 octets avec 1 bit de signe, 52 bits de
• Long : codé sur 10 octets avec 1 bit de signe, 64 bits de
- C accepte les constantes flottante en notation décimale ou

scientifique
13
Types de base
Le type caractère
Ensemble de définition : la table ASCII

Opérations sur les caractères :
SUCC(c) : caractère suivant dans la table ASCII;
PRED(c) : caractère précédent dans la table ASCII.
Notation algorithmique : c1,c2 : caractère
Notation C : char c1, c2;
14

Types de base
Taille et amplitude du type caractère
La table ASCII code tous les caractères usuels (états-uniens) sur 7

bits (128 positions). Sur un octet (8 bits), en C, on dispose :
du type char défini sur [−128..127];
du type unsigned char défini sur [0..255].
15

Types de base : Caractères spéciaux
NOTATION RESULTAT
\a cloche ou bip (alert ou audible bell)
\b Retour arrière (Backspace)
\f Saut de page (Form Feed)
\n Saut de Ligne (Line Feed)
\r Retour chariot (Carriage Return)
\t Tabulation horizontaLe (HorizontaL Tab)
\v Tabutation verticale (VerticaL Tab)
\\ \
\' ‘
\ '' ‘’
\? ? 16

Types de base
Tableaux
Déclaration de tableaux
• Un tableau (array) est une collection de variables de même

type, appelées éléments
• On les déclare par un type, un nom et une dimension
(CONSTANTE) placée entre [ ]
• Le C alloue toujours un tableau dans une zone contigüe de
la mémoire
• Une fois déclaré, on ne peut redimensionner un tableau
17

Types de base
Exemples
int tab[4]; déclare un tableau !
tab[0] tab[1] tab[2] tab[3]
de 4 valeurs entières
#define SIZE 10
int a[SIZE]; /* a est un vecteur de 10 entiers */
le compilateur réserve SIZE places en mémoire pour

ranger les éléments du tableau.
float A[5] = { 10.1, 20.3, 30.5, 40.0, 50.4 };

18
d’Algorithmique
Cours d’Algorithmique
Cours etenProgrammation
et Programmation Langage C en Langage C
Les structures en algorithmique et en C
LesTableaux
bases de la programmation
Tableaux
Types de base
• Les éléments sont numérotés de 0 à dim-1 !

• Il n’y a pas de vérification de bornes
void main() a
void main()
{ 59 0
{
int a[6];
? 1
int i = 7; int i;
? 2
int A[6] = { 1, 2,3, 5, 7, 11 };
a[0] = 59; 2 3
a[5] = -10; for (i=0;i<6;i++)
a[i/2] = 2; ? 4
printf("%d ", A[i]);
-10 5
a[6] = 0; }
a[-1] = 5;
}
Les tableaux consomment beaucoup de place mémoire. On

a donc intérêt à les dimensionner au plus juste. 19

Les variables
Variable
C’est un nom donné à une valeur.
Un nom de variable représente une et une seule valeur qui peut

évoluer au cours du temps (la valeur antérieure est perdue).
Déclaration
On déclare une variable en lui donnant un nom et un type.
Déclaration algorithmique : tension,puissance : flottant

Déclaration C : float tension, puissance;
20

Les constantes
Définition
C’est une « variable » qui ne change pas de valeur au cours
du programme.
Une constante doit toujours recevoir une valeur dès sa

déclaration.
Notation algorithmique : phi ← 1.618 : flottant
Notation C : const float phi = 1.618;
21

TYPE de la valeur de retour
"main" : Cela signifie "principale",

ses instructions sont exécutées.
void main(void): La fonction main ne
int main(void)
prend aucun paramètre et ne retourne
{
pas de valeur.
begin /* corps du programme*/
declaration des Cstes et Var ; int main(void): La fonction main
instruction1 ; retourne une valeur entière à l'aide de
instruction2 ; l'instruction return (0 si pas d’erreur).
….
int main(int argc, char *argv[]): On
}
end obtient alors des programmes auxquels
Entre accolades "{" et "}" on peut adresser des arguments au
on mettra la succession moment où on lance le programme.
d'actions à réaliser.(Bloc) 22

L’affectation
Définition
C’est l’opération qui permet de donner une valeur à une variable.
Dans une affectation, le membre de gauche reçoit le membre de

droite (ce qui nécessite deux temps d’horloge différents).
Notations algorithmiques :
index ← 3
i ← i +1
Notations C :
index = 3; // Attention!
i = i + 1; // ce n’est pas l’égalité mathématique
23
Entrées/Sorties
Les entrées/sorties
Ces deux opérations de base permettent de dialoguer : soit on
saisit une valeur (i-e l’ordinateur attend une valeur pour une
variable), soit on l’affiche à l’écran.
Notations algorithmiques :
ECRIRE (”Entrez une couleur primaire”)
LIRE (couleurPrim)
Notations en C :
printf
scanf
24
Entrées/Sorties
Les possibilités de la fonction printf
La fonction printf a comme 1er argument une chaîne de
caractères qui spécifie:
▪ Des caractères à afficher tels quels;
▪ Des code de format repérés par %. Un code
de conversion (c, d, f..) précise le type de
l’information à afficher.
Exemple: printf("leur somme est : %d",n1+n2);
25
d’Algorithmique
Cours et enProgrammation
Les Entrées/Sorties
Entrées/Sorties
Les principaux codes de conversion:
• c : char: caractère affiché ''en clair" (convient aussi à short

ou à int compte tenu des conversions systématiques)
• d : int (convient aussi à char, compte tenu des
conversions systématiques)
• u : unsigned int (convient aussi à unsigned char ou à
unsigned short, compte tenu des conversions
systématiques)
• ld : long
• lu : unsigned long
26
Cours d’Algorithmique et Programmation
Programmation en
en Langage
Langage C
C
Entrées/Sorties
• f : double ou float écrit en notation "décimale" avec six
chiffres après le point
• e : double ou float écrit en notation ‘'exponentielle''
(mantisse entre 1 et 9) avec six chiffres après le point
décimal, sous la forme x.xxxxxxe+yyy ou x.xxxxxxe-yyy
pour les nombres positifs et -x.xxxxxxe+yyy ou -
x.xxxxxxe-yyy pour les nombres négatifs
• s : chaîne de caractères dont on fournit l'adresse
(notion qui sera étudiée ultérieurement)
27
Cours d’Algorithmique et Programmation
Programmationen
enLangage
LangageCC
Entrées/Sorties
Action sur le gabarit d’affichage:
Les entiers sont affichés par défaut sans espaces avant ou
après. Les flottants avec six chiffres après le point.
Pour agir sur l’affichage ➔ un nombre est placé après %
et précise le nombre de caractère minimum à utiliser.
Exemples: printf("%3d" , n );
n = 20 ^20
n=3 ^^3
n = 2358 2358
n = -5200 -5200
28
Cours d’Algorithmique et en
et Programmation Programmation
Langage C en Langage C
Entrées/Sorties

Exemples :
printf("%f" , x );
x = 1.2345 1.234500
x = 12.3456789 12.345678
printf("%10f" , x );
x = 1.2345 ^^^1.234500
29
d’Algorithmique
Entrées/Sorties
Actions sur la précision :
pour les flottants, on peut préciser un nombre de
chiffres après le point décimal
Exemples: printf("%10.3f" , x );
x = 1.2345 ^^^^^^1.235
30
d’Algorithmique
Entrées/Sorties

Remarques:
Cadrage de l’affichage à gauche ➔ printf("%-10.3f" , x );
x = 1.2345 ➔ 1.235^^^^^
- Le caractère * figurants à la place d’un gabarit ou une
précision signifie que la valeur effective est fournie dans
la liste des arguments de printf :
printf("%8.*f" , n, x );
n=1; x=1.2345 ➔ ^^^^^^1.2
- La fonction printf fournit une valeur de retour (nombre
de caractère affichés)
31
Entrées/Sorties

Les erreurs de programmation :
Erreur 1 : Code de format en désaccord avec le type de

l’expression à afficher:
Conséquence : mauvaise interprétation si même taille (int

en %u), sinon, conséquences plus désastreuses.
32
d’Algorithmique
Entrées/Sorties
Erreur 2: Nombre de code de format différents du nombre
d’expressions de la liste
Conséquence 1 : si des expressions de la liste n’ont pas de

format, elles ne seront pas affichées ( printf("%d" , n, p );
// valeur de p ne sera pas affiché )
Conséquence 2 : s’il y a trop de code de format, printf

cherchera à afficher n’importe quoi ( printf("%d %d" , n );
n=8 ➔ 8 2 )
33
d’Algorithmique
Cours et Programmation
et Programmation en Langage C en Langage C
Les possibilités de la fonction scanf
Entrées/Sorties

Les principaux codes de conversion :
• c : char
• d : int
• u : unsigned int
• hd : short int
• hu : unsigned short
• ld : long
• lu : unsigned long
• f ou e : float écrit en notation "décimale" ou ‘'exponentielle''
34
d’Algorithmique
Entrées/Sorties

• Lf ou le : double écrit en notation "décimale" ou
‘'exponentielle''
• s : chaîne de caractères dont on fournit l'adresse (notion qui
sera étudiée ultérieurement)
Premières notion de tampon et de séparateurs :
Lorsque scanf attend des données, l’information frappée au
clavier est rangée temporairement dans l’emplacement
mémoire nommé « tampon ». Ce dernier est exploré caractère
par caractère au fur et à mesure des besoins. Certains
caractères jouent un rôle particulier: les séparateurs (l’espace
et la fin de ligne \n) 35
d’Algorithmique
Entrées/Sorties
Les premières règles utilisées par scanf :
Exemples : (n et p sont de type int, c char, @ désigne une

fin de ligne)
scanf("%d%d" , &n, &p );
12^25@ n = 12 p=25
^12^^25^^@ n = 12 p=25
scanf("%d%c" , &n, &c );
12â@ n = 12 c=‘ ‘
12a@ n = 12 c=‘a ‘
36
Entrées/Sorties

On peut imposer un gabarit maximal :
Le traitement d’un code de format s’interrompe soit à la
rencontre d’un séparateur, soit lorsque le nombre de caractère
indiqué a été atteint !!
Exemples : (n et p sont de type int, @ désigne une fin de ligne)

scanf("%3d%3d" , &n, &p );
12^25@ n =^12 p=^25
^^^^^12345@ n = 123 p=^45
12@
25@ n =^12 p=^25 37
d’Algorithmique
Entrées/Sorties
Rôle d’un espace dans le format :
Un espace entre deux codes de format demande à scanf de
faire avancer le pointeur au prochain caractère différent d’un
séparateur !!
Exemples : (n et p sont de type int, c char, @ désigne une fin

de ligne)
scanf("%d %c" , &n, &c );
12â@ n = 12 c=‘a‘
12^^^@
a@ n = 12 c=‘a‘ 38
Entrées/Sorties
Entrées/Sorties
Problème de synchronisation entre l’écran et le clavier :

Examinons cet exemple:
#include <stdio.h> →Vider le
main()
tampon
{ char n, p;
printf("donner une valeur pour n : ");
→Ajouter
scanf("%c",&n);
l’instruction
printf("Merci pour %c\n",n);
fflush(stdin);
fflush(stdin);
après chaque
scanf
printf("donner une valeur pour p : ");
scanf("%c",&p); Exécute
printf("Merci pour %c\n",p); Exécute 39
}
Entrées/Sorties
Le tampon n’est pas vide à chaque nouvel appel de scanf

#include<stdio.h>
Erreurs de programmation :
#include<conio.h>
1-main()
Code de format en désaccord avec le type de
l’expression:
{ char a[10];
printf("donner une valeur pour a : ");
Si même taille → introduction d’une mauvaise valeur
scanf("%d",&a);
la variable a une taille inférieur → écrasement d’un
Si fflush(stdin);
printf("Merci
emplacement pour %d\n",a);
mémoire onsécutif à cette variable
2- Nombre de codes de format différent du nombre
printf("donner une valeur pour a : ");
d’éléments de la liste:
scanf("%c",&a);
scanf("%d",&n, → seule la valeur de n est lue
&p);%c\n",a);
printf("Merci pour
getch();
scanf("%d%d",&n); → on affecte
}
Exempleune valeur à un
emplacement aléatoire de la mémoire
40
Entrées/Sorties
Les codes de format pour les fonctions printf et scanf
41
Entrées/Sorties
Les codes de format pour les fonctions printf et scanf
42
Entrées/Sorties
Exemple d’utilisation des codes de format pour les

fonctions printf et scanf
43
Entrées/Sorties
44
Entrées/Sorties
45
Les fonctions d’affichages et de saisies

Librairie : stdio.h
Fonction Syntaxe Description
printf printf( const char *format [, arg [, Écriture formatée

arg]...]); sortie standard
scanf scanf( const char *format [, arg [, Lecture formatée

arg]...]); entrée standard
putchar putchar(int c); Écrire le caractère c
getchar getchar(); Lecture d'un caractère

getch getch(); <conio.h>
puts *puts(char *s); Ecriture/Lecture d'une

chaîne de caractères,
gets *gets(char *s);
terminée par \n
sprintf sprintf(char *s, char *format, arg Ecrit dans la chaîne
...); d'adresse s.
sscanf sscanf(char *s, char *format, Lit la chaîne d'adresse

pointer ...); s.

Instruction
Un programme est constitué d’instructions...
Une instruction est une expression du langage qui peut être soit
simple soit composée (on parle alors d’un bloc d’instructions).
En algorithmique :
on écrit une instruction simple par ligne;
un bloc d’instruction, dans une structure, est délimité par un
début et une fin.
en C :
une instruction simple est suivie par un terminateur (;) le
point virgule;
un bloc d’instructions est un ensemble d’instructions
simples, encadrés par une paire d’accolades : { bloc
instructions }. 47

Trace d’und’algorithme
Traçage algorithme
Cette technique permet de suivre pas à pas l’exécution d’un

algorithme.
On numérote les instructions de l’algorithme et, dans un tableau,
on suit l’évolution des variables intéressantes :
Algorithme inconnu Trace de l’algorithme
DébutDéclaration N a b
a,b : entier
FinDéclaration 1 4
1 a←4 2 11
2 b ← 11
3 a←b−a 3 7
4 b←b−a 4 4
5 a←a+b
5 11
L’algorithme inconnu permute les valeurs de a et b. 48

Structure d'un programme C
Directives du préprocesseur :
#include <stdio.h>
accès avant la compilation
#define DEBUT -10
#define FIN 10
#define MSG "Programme de démonstration\n"
Déclaration des fonctions
int fonc1(int x);
int fonc2(int x);
void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */ Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définitions
} des fonctions
int fonc2(int x) {
return (x * x);
}
49
Cours d’Algorithmique et Programmation en
Langage C
Préprocesseur
Le préprocesseur effectue un prétraitement du programme
source avant qu'il soit compilé.
Ce préprocesseur exécute des instructions particulières appelées
directives.
Ces directives sont identifiées par le caractère # en tête.
Inclusion de fichiers
#include <nom-de-fichier> /* répertoire standard */
#include "nom-de-fichier" /* répertoire courant */
50

Préprocesseur
La gestion des fichiers (stdio.h) /* Entrees-sorties standard */

Les fonctions mathématiques (math.h)
Taille des type entiers (limits.h)
Limites des type réels (float.h)
Traitement de chaînes de caractères (string.h)
Le traitement de caractères (ctype.h)
Utilitaires généraux (stdlib.h)
Date et heure (time.h)
51
Deuxième partie
Les instructions en
algorithmique et en langage C
52
Sommaire de la Partie II
Les instructions en algorithmique et en C

Opérateurs arithmétiques
Opérateurs relationnels
Opérateurs booléens
Opérateurs binaires
Priorités des opérateurs
53

Opérateurs arithmétiques
Les opérateurs arithmétiques
addition + a + b
soustraction − a − b
opposé − −a
produit ∗ a ∗ b
division / a/b (attention à la division entière)
modulo % a%b (pour les types entiers)
De plus, en C :
incrémentation ++ pré : ++a ou post : a++
décrémentation -- pré : --a ou post : a--
54
Opérateurs relationnels
Les opérateurs relationnels
opérateur algorithmique C
égal == ==
différent ≠ !=
inférieur < <
supérieur > >
inférieurouégal <= <=
supérieurouégal >= >=
55
Opérateurs booléens
Les opérateurs booléens
opérateur algorithmique C
négation NON(a) !a
ou a OU b a || b
et a ET b a && b
56

Opérateurs binaires
Les opérateurs C binaires
Ces opérateurs C, très proches de la machine, servent à manipuler

des mots bit à bit, par exemple pour faire des masques :
et binaire & a & b

ou binaire | a | b
ou exclusif binaire ^ a ^ b
décalage gauche << a << b
décalage droit >> a >> b
57

Priorités des opérateurs
Priorités des opérateurs arithmétiques
Il est sage d’utiliser la règle pratique suivante :
Niveau de priorité Opérateurs arithmétiques

1 * / %
2 + -
Entourez tout le reste de parenthèses!
58
Troisième partie III

Les structures de contrôle
59
Sommaire de la Partie III

Sélection
Boucle Faire .. TantQue
Boucle TantQue .. FinTantQue
Boucle Pour .. FinPour
Ruptures de boucle
60


Alternative:
Si – Si non – Fin si If-else
Choix Multiple:
Selon Switch-case
Itérations:
Pour, Tant que, Répéter for, while, do-while
Rupture de Contrôle:
Retourner break, continue, return … goto
61
Sélection
Notations de la sélection simple
Sélection simple : notation algorithmique

Si (condition)
bloc instructions
FinSi
Sélection simple : notation C

if(condition)
bloc_instructions
62
Sélection
Notations de la sélection complète
Sélection complète : notation algorithmique
Si (condition)
bloc instructions
Sinon
bloc instructions
FinSi
Sélection complète : notation C

if(condition)
bloc_instructions
else
bloc_instructions
63
Sélection
Sélection complète : exemple algorithmique
DébutDéclaration
a ← 1.0,b ← −1.0,c ← −1.0 : réel
delta ← (b ∗ b) − 4 ∗ (a ∗ c),r : réel
FinDéclaration
Si (delta < 0)
Afficher(”Pas de solution réelle”)
Sinon
Si (delta == 0)
Afficher(”une solution double : ”, −b/(2 ∗ a))
Sinon
r ← Racine(delta)
Afficher(”deux solutions réelles : ”, (−b − r)/(2 ∗ a),
” et ”, (−b + r)/(2 ∗ a))
FinSi
FinSi 64
Sélection
Sélection complète : exemple C
#include <math.h>
int main(void)
{ double a = 1.0, b = -1.0, c = -1.0, delta = (b*b)-4.0*(a*c), r;
if(delta < 0)
Printf ("Pas de solutions reelles“ );
else
if(delta == 0)
Printf ("Une solution double : “ (-b/(2.0*a)));
else
{ r = sqrt(delta);
Printf ( "Deux solutions reelles : “ ((-b-r)/(2.0*a))
" et " ((-b+r)/(2.0*a)) );
}
} 65
Boucle Répéter .. TantQue
Notations de la boucle Répéter .. TantQue
Boucle Faire .. TantQue : notation algorithmique

Répéter
bloc instructions
TantQue(condition)
Boucle Faire .. TantQue : notation C

do
bloc_instructions
while(condition);
66
Notations de la boucle Répéter .. TantQue
(guarantit l’exécution au moins une fois)
bloc d' do
instructions {
............; /* bloc
d'instructions */
condition
non ............;
oui vraie }
while (expression);
suite du programme
j=5 i=1;
int j = 5; j=4 do i=1
do j=3 { printf(“i=%d ",i); stop
printf("j = %i\n", j--); j=2 i++;
while (j > 0); j=1 } while(i<0);
printf("stop\n"); stop printf("stop\n"); 67

Répéter .. TantQue : exemples algorithmiques

Répéter exemple 1 de saisie filtrée
Afficher(”Entrez un entier < 4 : ”)
Saisir(n)
TantQue(n >= 4)
Répéter exemple 2 de saisie filtrée

Afficher(”Entrez un entier [4..9] : ”)
Saisir(n)
TantQue((n < 4)OU(n > 9))
68
Répéter .. TantQue : exemples C
do // Exemple 1 de saisie filtree
{ Printf ( "Entrez un entier < 4 : “ );
Scanf (“%d”, &n);
} while(n >= 4);
do // Exemple 2 de saisie filtree

{ Printf ("Entrez un entier [4 .. 9] : “ );
Scanf (“%d”, & n);
} while((n < 4) || (n > 9));
69

Notation de la boucle TantQue .. FinTantQue

TantQue (condition)
bloc instructions
FinTantQue
Boucle Faire .. TantQue : notation C
while(condition)
bloc_instructions
70
d’Algorithmique et Programmation en Langage C
Cours
LA BOUCLE TANT QUE ... FAIRE ...

Notation
Boucle TantQue .. de la boucle TantQue .. FinTantQue
FinTantQue
Boucle pré-testée
Il s'agit de l'instruction while : tant que, pas jusqu’à ce que!
tant que (expression vraie) Syntaxe en C:

faire{BLOC D'INSTRUCTIONS} while (expression)
Organigramme: { ............; /*bloc d'instructions */
............;
............; }
Le test se fait d'abord, le bloc
d'instructions n'est pas forcément
exécuté.
Rq: les {} ne sont pas nécessaires
lorsque le bloc ne comporte
qu'une seule instruction. 71

TantQue .. FinTantQue : exemple algorithmiqu
DébutProgramme
DébutDéclaration
n ← 32 : entier entier à tester
cpt ← 0 : entier compteur de divisions par 2 de n
FinDéclaration
TantQue (n%2 == 0)
n ← n/2
cpt ← cpt + 1
FinTantQue
Afficher(”32 est ”, cpt, ” fois divisible par 2.”)

FinProgramme
72

TantQue .. FinTantQue : exemple C
int main(void)
{
int n = 32, cpt = 0;
while((n % 2) == 0)
{
n = n / 2;
cpt = cpt + 1;
}
Printf ("32 est “ cpt " fois divisible par 2.“ );
}
73
Notation de la boucle Pour .. FinPour
Boucle Pour .. FinPour : notation algorithmique
Pour cpt Dans [a..b] ParPasDe n
bloc instructions
FinPour
Boucle Pour .. FinPour : notation C
for(expression_1; expression_2; expression_3)
bloc_instructions
Où expression_1 initialise la variable de contrôle, expression_2

donne la condition de rebouclage et expression_3 incrémente la
variable de contrôle en fin de bloc_instructions. 74

Pour .. FinPour : exemple algorithmique

DébutProgramme Calcul de factorielle 5
DébutDéclaration
n ← 5,fact ← 1,cpt : entier
FinDéclaration
Pour cpt Dans [1..n] ParPasDe 1
fact ← fact*cpt
FinPour
Afficher(”5! = ”, fact)
FinProgramme
75

Pour .. FinPour : exemple C
int main(void)
{
long n = 5, fact = 1;
for(long cpt = 1; cpt <= n; cpt = cpt + 1)
{
fact = fact * cpt;
}
Printf (n "! = “ fact );
}
76

Boucle Selon
Notations de la boucle Selon

Boucle Selon : notation algorithmique
Selon <identificateur>
(liste de) valeur(s) : instructions
(liste de) valeur(s) : instructions
…
[ Autres : instructions]
77
Cours d’Algorithmique et Programmation en et Programmation
Boucle Selon
Boucle Selon
Boucle Switch: notation C

switch(var de type char ou int) /* au cas où la variable vaut: */
{
case valeur1: ....; /* valeur1(étiquette): exécuter ce bloc
d'instructions.*/
break; /* L'instruction d'échappement break; permet de
quitter la boucle ou l'aiguillage le plus proche. */
case valeur2:.....; /* valeur2: exécuter ce bloc d'instructions.*/
break; /* etc ...*/
default: .......; /* aucune des valeurs précédentes: exécuter ce
bloc d'instructions, pas de "break" ici.*/
}
78
Boucle Selon
Boucle Selon
char choix;
printf("SAISIE TAPER 1\n");
printf("AFFICHAGE TAPER 2\n");
printf("POUR SORTIR TAPER S\n");
printf("\nVOTRE CHOIX: ");
choix = getchar();
switch(choix)
{
case '1': .......; break;
case '2': ......; break;
case 'S': printf("\nFIN DU PROGRAMME ...."); break;
default; printf("\nCE CHOIX N'EST PAS PREVU "); /* pas de
break ici */
}
79

Ruptures de boucle
Les instructions C de ruptures de boucle

Le langage C offre deux instructions :
break provoque la fin prématurée de la boucle while, do ou

for qui contient directement le break;
continue provoque le rebouclage immédiat, comme si on

venait d’exécuter la dernière instruction du corps de la boucle.
80
d’Algorithmique
Ruptures de boucle
Ruptures de boucle
Pour rompre le déroulement séquentiel d'une suite d'instructions
Continue; 8
Break; #
for (i = -10; i <= 10; i++)
int i, j=1;
char a; {
for (i = -10; i <= 10; i++){ if (i == 0)
continue;
while(j!=0) /* boucle // pour éviter la division par zéro
infinie */ printf(“ %f”, 1 / i);
{ }
a=getchar();
return (expression);
if(a= ='x')
permet de sortir de la fonction qui la
break;
contient
}
} exit (expression); La fonction est interrompu.
expression : un entier indiquant le code de
Si x est tapée au clavier
terminaison du processus 81
d’Algorithmique
Ruptures de boucle
Ruptures de boucle
goto étiquette #include <stdio.h>

void main()
{ int i, j;
for (i=0; i < 10; i++)
for (j=0; j < 4; j++) {
if ( (i*j) == 10)
goto trouve;
printf("i*j != 10.\n");
}
trouve:
printf("i*j =%d * %d = %d== 10.\n",i,j,i*j);
} 82
Quatrième partie IV
Les fonctions en algorithmique
et en C
83
Sommaire de la Partie IV
Les fonctions
Caractéristiques
Notation
Le passage des arguments
Récursivité
84
d’Algorithmique
Les fonctions
Caractéristiques
Les fonctions
Caractéristiques
◼ En C : fonction (Définition, Déclaration et Appel).

◼ Une fonction peut avoir autant de paramètres que l’on veut,
même aucun (comme void main(void))
◼ Une fonction renvoie une valeur ou aucune.
◼ Les variables déclarées dans une fonction sont locales à cette
fonction
◼ Une fonction possède un et un seul point d'entrée, mais
éventuellement plusieurs points de sortie (à l'aide du mot
return).
◼ L'imbrication de fonctions n'est pas autorisée: une fonction ne
peut pas être déclarée à l'intérieur d'une autre fonction. Par
contre, une fonction peut appeler une autre fonction. Cette
dernière doit être déclarée avant celle qui l'appelle.
85
Les fonctions
Notation
Notation algorithmique
L’écriture d’une fonction requiert un en-tête et un corps :
l’en-tête comprend : DébutFonction, le nom de la fonction, une
liste d’arguments entre parenthèses, puis le type de la fonction.
Les arguments sont séparés par une virgule.
notés → nom_arg : type_arg ;
le corps se termine par FinFonction précédé d’une instruction

de retour d’une expression de même type que la fonction.
Exemple :
DébutFonction Doubler(→ x : flottant) : flottant
Retourner (2 ∗ x)
FinFonction 86
Les fonctions
Notation
Notation C
L’écriture d’une fonction requiert un en-tête et un corps :
l’en-tête comprend : le type de retour, le nom de la fonction
suivit d’une liste d’arguments entre parenthèses. Les
arguments sont séparés par une virgule et sont notés :
Type_arg nom_arg, type_arg nom_arg, ...
le corps est un bloc d’instructions précédé d’une instruction de
retour d’une expression de même type que la fonction.
Exemple :
float Doubler(float x)
{ return 2.0*x;
}
87
d’Algorithmique
Les fonctions
Notation
Les fonctions
Notation C
Notation
Notation C
Une fonction possède trois aspects :
le prototype : c’est la déclaration nécessaire avant tout;
l’appel : c’est l’utilisation d’une fonction àl’intérieur d’une

autre fonction (par exemple le programme principal);
la définition : c’est l’écriture proprement dite de la

fonction, en-tête et corps.
88
Les fonctions
Notation
Déclarer une fonction

TYPE de la valeur de retour 3 doubles comme paramètres
int print_table(double start, double end, double step)

{
double d; Nom de la fonction
int lines = 1;
printf("Celsius\tFarenheit\n");
for(d = start; d <= end; d += step, lines++)
printf("%.1lf\t%.1lf\n", d, d * 1.8 + 32);
return lines;
}
Valeur renvoyée 89
d’Algorithmique
Les fonctions
Notation
Les fonctions
Notation
Appeler une fonction

IMPORTANT: cette instruction spécifie comment la fonction est définie
#include <stdio.h>
int print_table(double, double, double);

void main(void)
{
int combien; Le compilateur attend
double end = 100.0; des doubles; les
conversions sont
combien = print_table(1.0,end,3); automatiques
print_table(end, 200, 15);
}
Ici, on ne tient pas compte de la valeur de retour 90
Les fonctions
Notation
Règles de visibilité des variables
Le C est un langage structuré en blocs { } , les variables ne
peuvent être utilisées que là où elles sont déclarées
void func(int x);
int glo=0; // variable globale
Le compilateur ne
void main(void)
{ int i = 5, j, k = 2; //lacales à main connaît pas d
float f = 2.8, g;
d = 3.7;
func (i);
}
void func(int v) Le compilateur ne
{ double d, e = 0.0, f =v; //lacales à func connaît pas i et g
i++; g--;glo++;
f = 0.0; C’est le f local
} qui est utilisé
91
d’Algorithmique
Les fonctions
LesPassage des paramètres

fonctions
Passage des paramètres par valeur
Passage des paramètres
Passage des paramètres par valeur

La fonction travaille sur des copies des paramètres et ne
peut modifier les paramètres
#include <stdio.h>
void change(int v);
void main(void)
{ int var = 5; change: v = 500
change(var); main: var = 5
printf("main: var = %d\n", var);
}
void change(int v)
{ v *= 100;
printf("change: v = %d\n", v);
}
92
Les fonctions
Return
Fonction renvoyant une valeur au programme
#include <stdio.h>
int change(int v);
void main(void)
{ int var = 5;
int valeur;
valeur = change(var); change: v =
printf("main: var = %d\n", var); main: var =
printf("main: valeur = %d\n", valeur); main: valeur =
}
int change(int v)
{ v *= 100;
printf("change: v = %d\n", v);
return (v+1);
} 93
d’Algorithmique
Les fonctions
Les Return
fonctions
ReturnFonction renvoyant une valeur au programme
Une fonction se termine et « rend la main » au code
appelant lorsque son exécution rencontre l’instruction :
return expression; ou return;
#include <stdio.h>
int return_Val(int v);
void main(void)
return_Val : rien
{ int var = 5;
main: var =
int valeur;
valeur = return_Val(var); main: valeur =
printf("main: valeur = %d\n", valeur);
}
int return_Val(int v)
{ if (v == 10) return (2*v);
else return (3*v);
94
}
Les fonctions
Récursivité
Fonction récursive
Une fonction est dite récursive si elle se fait appel pour
calculer une sous partie de la valeur finale qu'elle retournera.
#include <stdio.h>
int fact(int n);
int return_Val(int v);
void main(void) return_Val : rien
{ int var = 5, int valeur; main: var =
valeur = return_Val(var); main: valeur =
printf("main: valeur = %d\n", valeur); }
int fact(int n)
{ if (n == 0) return 1; (0)=0*fact(-1)
else return n * fact(n - 1); }
int return_Val(int v) int temp=1;
{ if (v == 10) return (2*v); while(n>1) temp*=n--;
else return fact(v); } 95
Les fonctions
Récursivité
Fonction récursive
int fact( int n) {
if (n < 1) return 1; void hanoi(int n, int
else return ( n * fact(n-1) a, int b){
); int c ;
} …
if (n == 1)
move(a,b);
else { hanoi(n-1, a,
c);
move (a,
b);
96
Cinquième partie V
Procédure, pointeurs et
tableaux
97
Sommaire de la Partie V
Les procédures, pointeurs et tableaux
Procédures
Pointeurs
Passage des arguments par adresse
Relation avec les tableaux
98
Procédures
Les procédures
Généralisant la notion de fonction, les procédures permettent
de modifier la valeur de plusieurs arguments;
Notation algorithmique proche de celle des fonctions, sauf :
DébutProcédure ...FinProcédure
pas de type de retour (donc pas d’instruction Retourner)
les arguments peuvent encore être en entrée (→) non
modifiés, mais peuvent aussi être modifiés en étant soit
en sortie (←) soit en entrée/sortie (↔)
Leur appel constitue à lui seul une instruction.
99

Procédures
Les procédures : échange de deux entiers
DébutProcedure Echanger(↔a : entier, ↔b : entier)
DébutDéclaration
temp ← a : entier variable temporaire
FinDéclaration
a←b
b ← temp
FinProcedure
void Echanger(int &a, int &b) // passage par reference

{ int temp = a; // variable temporaire
a = b;
b = temp;
} 100
Pointeurs
Les pointeurs
Un pointeur est une variable particulière, dont la valeur est
l'adresse d'une autre variable.
• Pointeur p: valeur 5A0F3 (adresse hexadécimale)
• Adresse 5A0F3: valeur 17 (correspondant à la valeur d'un entier i)
En accédant à cette adresse, on peut accéder indirectement à
la variable et donc la modifier.
i=17
5A0F3 17
p=5A0F3
p i
Un pointeur est une adresse mémoire. On dit que le pointeur p
pointe vers i, puisque p pointe vers l’emplacement mémoire où est
enregistrée i. 101
Cours
Les pointeurs, tableaux et procédures
LesPointeurs
procédures, pointeurs et tableaux
Les pointeurs
Pointeurs
Les pointeurs
• Les pointeurs sont nécessaires pour:
– effectuer les appels par référence (i.e. écrire des
fonctions qui modifient certains de leurs paramètres)
– manipuler des structures de données dynamiques (liste,
pile, arbre,…)
– allouer dynamiquement de la place mémoire
Déclaration des pointeurs
Le symbole * est utilisé entre le type et le nom du pointeur
• Déclaration d’un entier: int i;
• Déclaration d’un pointeur vers un entier: int *p;
102
Cours
LesPointeurs
Les pointeurs
Pointeurs
Exemples de déclarations de pointeurs

int *pi; /* pi est un pointeur vers un int *pi
désigne le contenu de l'adresse */
float *pf; /* pf est un pointeur vers un float */
char c, d, *pc; /* c et d sont des char*/

/* pc est un pointeur vers un char */
double *pd, e, f; /* pd est un pointeur vers un double*/
/* e et f sont des doubles */
double **tab; /* tab est un pointeur pointant sur un
pointeur qui pointe sur un flottant
double */
103
Pointeurs
Opérateurs unaires pour manipuler les pointeurs, & (adresse de) et * (contenu)
Exemple: int i = 8;
printf("VOICI i: %d\n",i);
printf("VOICI SON ADRESSE EN HEXADECIMAL: %p\n",&i);
nom_de_Pointeur = &nom_de_variable
void main(void) p c
{ char c = 'a', d = 'z';
0x1132 0x1132 'a'
char *p;
p d
p = &c; 0x91A2 'z'
*p = c; 0x91A2
printf("%c\n", *p);
p = &d; L’opérateur * (“valeur pointée
par”)
printf("%c\n", *p);
} a
z
104
#include <stdio.h>
void main() {
int *p, x, y;
p = &x; /* p pointe sur x */
x = 10; /* x vaut 10 */
y = *p - 1; printf(" y= *p - 1 =? = %d\n" , y); y vaut ?
*p += 1; printf(" *p += 1 =? *p = x= ? = %d %d\n" , *p, x); x vaut ?
(*p)++; printf(" (*p)++ =? *p = x= ? = %d %d alors y=%d \n" , *p,
x, y);
incrémente aussi de 1 la variable pointée par p, donc x vaut ??.
y vaut 9
*p=0; printf(" *p=0 x=? = %d\n" , x);

comme p pointe sur x, maintenant x vaut ?
*p++; *p=20; printf(" *p++ x=? = %d\n" , x);
} comme p ne pointe plus sur x, x vaut tjr ? 105
d’Algorithmique
LesPointeurs
Les pointeurs
Pointeurs
Utiliser des pointeurs

• On peut donc accéder aux éléments par pointeurs en faisant
des calculs d’adresses (addition ou soustraction)
long v[6] = { 1,2, 3,4,5,6 };

long *p; p += 4
p = v; p++
printf("%ld\n", *p); 1 p
p++; 2
printf("%ld\n", *p);
1000 v 1 2 3 4 5 6
6 1000 1008 1016
p += 4;
printf("%ld\n", *p); 1004 1012 1020
106
Cours
LesPointeurs
Les pointeurs
Pointeurs
Les pointeurs
* et ++
*p++ signifie:
*p++trouver la valeur pointée
*p++passer à l’adresse suivante
(*p)++ signifie: !
(*p)++ trouver la valeur pointée
(*p)++ incrémenter cette valeur (sans changer le pointeur)
*++p signifie:
*++pincrémenter d’abord le pointeur
*++ptrouver la valeur pointée
107
Cours
LesPointeurs
Les pointeurs
Pointeurs
Identification des tableaux et pointeurs

▪ En C, le nom d’un tableau représente l’adresse de sa
composante 0, donc a == &a[0]
▪ C'est pour cela que les tableaux passés comme paramètres
dans une fonction sont modifiables
◼ Pour le compilateur, un tableau comme argument de fonction,
c’est un pointeur vers sa composante 0 (à la réservation
mémoire près).
◼ La fonction peut donc modifier n’importe quel élément
(passage par référence)
◼ Le paramètre peut soit être déclaré comme tableau, soit
comme pointeur
int add_elements(int a[], int size) int add_elements(int *p, int size)
{ { 108
Exemple
#include <stdio.h> Tab Tab
void sum(long [], int); 1 29
int main(void)
{ long Tab[6] = { 1, 2, 3, 5, 7, 11 }; 2 2
sum(Tab, 6); 3 3
printf("%ld\n", Tab[0]); 5 5
return 0;
7 7
}
11 11
void sum(long a[], int sz) a
{ int i;
long total = 0; sz 6
for(i = 0; i < sz; i++)
total += a[i];
a[0] = total;
}
109
Utiliser des pointeurs - exemple
#include <stdio.h>
long sum(long*, int);
Tab Tab
int main(void)
{ long Tab[6] = { 1, 2, 3, 5, 7, 11 }; 1 1000 1
printf("%ld\n", sum(Tab, 6)); 2 1004 2
return 0; 3 3
1008
}
5 1012 5
long sum(long *p, int sz) 7 1016 7
{ long *end = p + sz; 11 1020 11
long total = 0;
while(p < end) 1024
total += *p++; p
return total; 1000
} end 1024
110
Sixième partie VI
Aspects avancés du langage C
111
Sommaire de la Partie VI
Quelques aspects avancés du langage C
Chaînes de caractères
Listes chainées
Gestion des fichiers
Structures
Allocation programmée
Arguments du main()
112

Les chaînes de caractères
En C, les chaînes de caractères sont des tableaux de char :
char str[] = "truc";
Dans leur représentation interne, ils doivent être terminés par le

caractère nul (valeur sentinelle) pour en détecter la fin. On parle
de chaîbien formée.
On les déclare soit comme un tableau de caractères (qui est
donc modifiable), soit comme un pointeur de caractères (chaîne
littérale constante).
113
d’Algorithmique
Traitements sur les chaînes

Les fonctions de traitements de chaînes sont définies dans l’en-
tête <string.h>. Les principales sont :
longueur : fonction strlen;
comparaison : fonction strcmp;

recopie : fonction strcpy;
concaténation : fonction strcat.
114
d’Algorithmique
Exemple de traitements sur les chaînes

// fonction strcpy(), version tableaux de caracteres
void strcpy(char s[], char t[])
{ int i = 0;
while((s[i] = t[i]) != ’\0’)

{ i = i + 1;
}
}
// fonction strcpy(), version pointeurs de caracteres

void strcpy(char *s, char *t)
{ while(*s++ = *t++)
; }
115
Listes chaînées
Listes chaînées
Une liste est une structure de données constituée de cellules
chaînées les unes aux autres par pointeurs.
Une liste simplement chaînée : une cellule est un enregistrement
qui peut être déclarée comme suit:
struct Node {
int data; /* les informations */
struct Node *next; /* le lien */
};
Une liste doublement chaînée
struct Node {
struct Node *next; /* lien vers le suivant */
struct Node *prev; /* lien vers le précédent */
}; 116
Listes chaînées
Structures de données dynamiques
typedef : mot réservé, typedef struct Node {
crée de nouveaux noms int data;
de types de données struct Node *next;
} cellule;
Ex :
typedef char * STRING; cellule * new_node(int value)
{ cellule * p;
fait de STRING un p = (cellule *)malloc(sizeof(cellule));
synonyme de "char *" p->data = value;
Portée : comme les p->next = NULL;
variables. return p;
}
p=new struct Node;
117
Listes chaînées
Nouvelle cellule dans une liste chaînée vide
cellule *debut; Denis\0
debut = (cellule *) malloc
(sizeof(cellule)); NULL
strcpy ( debut->name, “Denis”); debut
debut->next = NULL;
Le début de la liste est indiqué par un pointeur indépendant

(debut) et la fin par NULL
Nouvelle cellule en début de liste chaînée
cellule *prec;
prec = (cellule *) malloc (sizeof(cellule));
strcpy ( prec->name, “Claire”);
Denis
prec->next = debut;
Claire
debut = prec;
NULL
debut
prec 118
Cours d’Algorithmique et Programmation enet Programmation
Listes chaînées
Listes chaînées
Nouvelle cellule après la cellule prec

cellule *p;
p = (cellule *) malloc (sizeof(cellule));
strcpy ( p->name, “Alfred”);
p->next = prec->next;
prec->next = p; OK?
Alfred
Alfred
p Denis
Denis
Claire
Claire
debut NULL
NULL
prec
prec
debut
119
Cours
Listes chaînées
Listes chaînées
Parcourir une liste
void parcours (struct Node *debut) debut est un pointeur
{ sur la cellule qui
struct Node *p;
p = debut;
contient le premier
while ( p != NULL) { élément de la liste
printf (“%s\n”, p->name);
p = p->next; Liste identifier par
} l'adresse de sa première
} cellule
Claire Alfred Denis
debut NULL
120
Cours
Listes chaînées
Listes chaînées
Listes chaînées
void liberation(liste L){

if (L) {
liste temp = L->suivant;
free(L); void liberation (liste *lis)
liberation(temp); {
} liste *p;
} while ( lis != NULL) {
p = lis;
lis=lis->next;
free(p);
}
}
121
Cours
Listes chaînées
Listes chaînées
Listes chaînées
Exemple
LIFO
Last-In-First-Out
• Le dernier élément ajouté dans la liste, est le premier à en

sortir.
• Opérations:
Créer la pile,
Ajouter un élément (Push),
Effacer un élément (Pop),
Eliminer la pile .
122
d’Algorithmique
Listes chaînées
Listes chaînées
Listes chaînées
Listes chaînées
PUSH procédure
Push(5)
7 3 9 5
Push(9)
NULL
Push(3)
Top Top Top Top
Push(7)
Overflow risk si la pile est pleine!!!

123
d’Algorithmique
Listes chaînées
Listes chaînées
Listes chaînées
Listes chaînées
POP procédure
Pop(7) 3
7 9 5
Pop(3) Underflow risk NULL
si la pile est vide !!!
Pop(9)
Pop(5) Top Top Top
Top Top
Top
124
Cours
Listes chaînées
Listes chaînées
Listes chaînées
Listes doublement chaînées

struct Node {
struct Node *prev; /* lien vers le précédent */ data prev next
struct Node *next; /* lien vers le suivant */
};
typedef struct Node Cell;
Cell *debut, *fin, *act;
int dim = sizeof(Cell);

debut
debut = (Cell *) malloc(dim);
fin = (Cell *) malloc(dim);
fin 125
Cours
Listes chaînées
Listes chaînées
doublement chaînées
Listes chaînées
Listes doublement chaînées

debut->prev = NULL;
data prev next
debut->next = fin;
fin->prev = debut;
fin->next = NULL;
NULL NULL
début fin
126
Listes chaînées
Insérer un élément en fin de liste

fin->next = act;
data prev next
act->prev = fin;
act->next = NULL;
fin = act;
NULL NULL
debut fin
NULL NULL
act fin
debut 127
Listes chaînées
Insérer un élément dans la liste pos = qlq

Cell *tmp;
tmp = (Cell *) malloc(dim); data prev next
tmp->prev = act->prev ;
act->prev->next = tmp;
tmp->next = act;
act->prev = tmp;
tmp
NULL NULL
act
debut fin 128
Gestion des fichier en C

Elle est assurée par la librairie standard <stdio.h> via un
ensemble de fonctions commençant par “f”
◼ Avant de manipuler un fichier, il faut lui associer un
descripteur (pointeur vers la structure fichier)
◼ Il y a 3 descripteurs automatiquement ouvert par tout
programme C, stdin, stdout et stderr
◼ stdin (standard input) est connecté au clavier. On peut y lire
◼ stdout (standard output)
◼ stderr (standard error) sont reliés au moniteur. On peut y
écrire.
!
FILE *f; /*déclare un descripteur f de fichier*/
129
Ouvrir et fermer des fichier en C

Les fichiers sont ouverts avec la fonction fopen
ils sont fermés avec la fonction fclose
FILE* fopen(const char* name, const char* mode);
int fclose (FILE *f); void main(void)
{ FILE* in;
FILE* out;
FILE* append;
in = fopen("autoexec.bat", "r");
out = fopen("autoexec.bak", "w");
append = fopen("config.sys", "a"); /* … */
fclose(in);
fclose(out);
fclose(append); }
130
Lecture et écriture sur fichier

Fonctions de lecture
int fscanf (FILE* stream, const char* format, ...);
int fgetc (FILE* stream);
char* fgets (char* buffer, int size, FILE* stream);
Fonctions d’écriture
int fprintf (FILE* stream, const char* format, ...);
int fputc (int ch, FILE* stream);
int fputs (const char* buffer, FILE* stream);
int feof(FILE *f); /*renvoie une valeur non nulle si fin de fichier*/
131
Exemple d’écriture (lecture) de fichier
#include <stdio.h> #include <stdio.h>
void sauvegarde( char titre[], int n, void main(void)
float x[], int ind [] ) { char titre[81];
float x[10];
{ int i=0;
int ind[10], i=0;
FILE *f;
FILE *f;
f = fopen(“monfichier.dat”,”w”);
f = fopen(“monfichier.dat”,”r”);
if (f !=NULL){
if (f!= NULL) {
fprintf(f,”%s\n”,titre);
fgets(titre,80,f);
for (i=0; i < n; i++ ) { while(!feof(f)) {
fprintf(f,”%f %d\n”, x[i],ind[i]); fscanf(f,”%f d”,&x[i],&ind[i]);
} i++; }
Mon titre
} }
3.0 1
fclose(f); 4.5 2 fclose(f); }
7.3 3
La constante NULL (définie comme 0 dans stdio.h) réfère à une
adresse non définie 132
Compiltion Séparée et édition de lien

Un programme C est un ensemble de fonctions dans un ou plusieurs fichiers.
Fichier PP.c Fichier PP.c Fichier SP.c

main(){ main(){ g(){
… … …}
appelle f() appelle f()
…} …}
f(){ f(){
appelle g()… appelle g()…
} }
g(){ …
}
Cas I Cas II
133
Manipulation des fichiers

Règles de visibilité des variables
Les variables ne peuvent être utilisées que là où elles sont déclarées
double func(int x);
#include <stdio.h>
int glob=0; // variable
globale int next() {
void main(void) static value = 0;
{ Int i = 5, j, k = 2; //lacales à main
glob++; return value++;
func (i); }
func (k); void main(void) {
}
double func(int v) printf("Appel 1 : %d\n",next());
{ double d, f =v; //lacales à func printf("Appel 2 : %d\n",next());
glob++;
}
f += glob; Appel 1 : 0
return f;
} Appel 2 : 1 134
d’Algorithmique
Variables et fonctions externes

Le fichier impose lui aussi
un domaine de visibilité.
Une variable définie globale
(en dehors de toute
fonction) ne sera alors
visible que par les fonctions
de ce fichier. Le problème
est de savoir comment
exporter cette variable pour
d’autres fonctions du
programme (externes au
module) si le besoin s’en
fait ressentir ?
135

Les structures en C
Les structures en C
◼ Concepts
◼ Créer un type de structure
◼ Créer une instance de structure
◼ Initialiser une instance
◼ Accéder aux membres d’une instance
◼ Passer les structures comme paramètres
◼ Listes chaînées
136

Les structures en C
Concepts
◼ Une structure est une collection de plusieurs variables
(champs) groupées ensemble pour un traitement commode
◼ Les variables d’une structure sont appelées membres et
peuvent être de n’importe quel type, par exemple des

tableaux, des pointeurs ou d’autres structures
Les étapes sont:
struct Membre
◆ déclarer le type de la structure
{
◆ utiliser ce type pour créer autant char nom[80];
d’instances que désirées char adresse[200];
int *numero;
◆ Accéder les membres des instances
float amende[10];
};
137

Les structures en C
Déclarer les structures
◼ Les structures sont définies en utilisant le mot-clé struct
struct Membre
struct Date { char nom[80];
{ int jour; char adresse[200];
int mois; int numero;
int an; float amende[10];
! }; struct Date emprunt;
struct Date creation;
};
struct Livre struct Pret

{ char titre[80]; { struct Livre b;
char auteur[80]; struct Date due;
float prix; struct Membre *who;
}; };
138

Les structures en C
Déclarer des instances
◼ Une fois la structure définie, les instances peuvent être
déclarées
◼ Par abus de langage, on appellera structure une instance de
structure
struct Date
{ int jour;
int mois;
int an;
} hier, demain; Déclaration
avant ‘;’ .
struct Date paques;
struct Date semaine[7];
struct Date nouvel_an = { 1, 1, 2001
}; Initialisation .
139

Les structures en C
Des structures dans des structures
struct Date
{ int jour;
int mois; struct Membre
int an; { char nom[80];
}; char adresse[200];
int numero;
float amende[10];
struct Membre m = {
struct Date emprunt;
"Arthur Dupont",
struct Date creation;
”rue de Houdain, 9, 7000
};
Mons",
42,
{ 0.0 },
{ 0, 0, 0 },
{ 5, 2, 2001 }
}; 140

Les structures en C
Accéder aux membres d’une structure
◼ Les membres sont accédés par le nom de l’instance, suivi de . ,
suivi du nom du membre
struct Membre m;
printf("nom = %s\n", m.nom);

printf(”numéro de membre = %d\n", m.numero);
printf(”amendes: ");
for(i = 0; (i < 10) && (m.amende[i] > 0.0); i++)
printf("%.2f Euros", m.amende[i]);
printf("\nDate d’emprunt %d/%d/%d\n", m.emprunt.jour,
m.emprunt.mois, m.emprunt.an);
141

Les structures en C
Passer des structures comme pramètres de fonction
◼ Une structure peut être passée, comme une autre variable,
par valeur ou par adresse
◼ Passer par valeur n’est pas toujours efficace (recopiage à
l’entrée)
◼ Passer par adresse ne nécessite pas de recopiage
void Par_valeur(struct Membre m);

void Par_reference(struct Membre *m);
Par_valeur(m);
Par_reference(&m);
142

Les structures en C
Quand la structure est un pointeur!
Utiliser p → name
◼ L’écriture p → name est synonyme de (*p) → name,
où p est un pointeur vers une structure
!
void affiche_membre (struct Membre *p)
{ printf("nom = %s\n", p->nom);
printf("adresse = %s\n", p->adresse);
printf(”numéro de membre = %d\n", p->numero);
printf("\nDate d’affiliation %d/%d/%d\n",
p->creation.jour, p->creation.mois, p->creation.an);
}
143

Les structures en C
Retour de structures dans une fonction

◼ Par valeur (recopiage) ou par référence
struct Complex add(struct Complex a, struct Complex b)
{ struct Complex result = a;
result.real_part += b.real_part;
result.imag_part += b.imag_part;
return result;
}
struct Complex c1 = { 1.0, 1.1 };

struct Complex c2 = { 2.0, 2.1 };
struct Complex c3;
c3 = add(c1, c2); /* c3 = c1 + c2 */
144

L’allocation programmée
Lorsqu’on utilise un tableau, on doit le déclarer en précisant son
type et sa taille. La taille est parfois inconnue a priori, on doit la
gérer àl’exécution. On parle d’allocation programmée ou de
tableaux dynamiques.
La bibliothèque standard C offre une fonction d’allocation,

malloc, qui attend une taille d’octets àallouer et retourne un
pointeur de void (void *), et une fonction de désallocation, free,
qui reçoit l’adresse d’une zone mémoire allouée par malloc (un
pointeur) et la rend au système d’exploitation.
145
Cours
L’allocation
programmée
L’allocation programmée
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{ char * str;
// allocation programmee
if ((str = (char *) malloc(10)) == NULL) {
printf("pas assez de memoire !\n");
exit(1); // sortie en erreur }
strcpy(str, "Bonjour");
printf("Message : %s\n", str);
free(str); // libere la memoire
return 0; } 146

Arguments du main()
Les arguments de la ligne de commande

On peut passer deux arguments à la fonction main() :
int argc nombre d’arguments de la ligne de commande;
char *argv[] contient les arguments, un par chaˆıne de
caractères.
#include <iostream>
using namespace std;
int main(int argc, char *argv[]) {
cout << "argc = " << argc << endl;
for(int i = 0; i <= argc; i = i + 1)
{ cout << "argv[" << i << "] = " << argv[i] << endl;
}
return 0;
} 147
Annexes
Les fonctions mathématiques
Les fonctions arithmétiques standard

Nom En C Rôle Exemple
Floor(X) arrondir en moins Floor (9.55) = 9
Arrondi(x)
Ceil(X) arrondir en plus Ceil (9.55) = 10
Abs(x) Fabs(X) valeur absolue de X ABS (-6) = 6
RacineCarré(x) Sqrt(X) racine carrée de SQRT(4) = 2
X s’il est positif
Pow(X,Y) X exposant Y Pow(2, 2) = 4
Fmod(X,Y) reste rationnel de Fmod(5.3, 2) = 1,300000
X/Y (même signe Fmod(18.5, 4.2) = 1,700000
que X) pour x
différent de 0
148
Annexes
Les fonctions trigonométriques

Arctan(X) Atan(double x) renvoie l’arc tangente de Arct(0.500000) = 26.565051
l’argument x
Atan2 (double x, renvoie l’arc tangente du rapport Arct(20.00000, 20.00000) =
double y) x/y 45,00000
Arccos(X), Acos(double x) renvoie l’arc cosinus d’un argument Acos(0.500000) =
x 60.000000
tel que –1 <= x <= 1
Arcsin(X), Asin(double x) renvoie l’arc sinus d’un argument x Asin(0.300000) = 17.457603
tel que –1 <= x <= 1
Cos(X) Cos(double x) renvoie le cosinus de l’argument x Cos(60.000000) = 0.500000
Sin(X) Sin(double x) Renvoie le sinus de l’argument x Sin(25.000000) = 0.422618
Tan(X) Tan(double x) Renvoie la tangente de l’argument x Tan(50.000000) = 1.191754
149
Annexes
Les fonctions hyperboliques

En C Rôle Exemple
Cosh(double x) renvoie le cosinus hyperbolique Cosh(2.302585) =
de l’argument x 5.050000
Sinh(double x) renvoie le sinus hyperbolique de Sinh(2.302585) =

l’argument x 4.950000
Tanh(double x) renvoie la tangente Tanh(0.693147) =

hyperbolique de l’argument x 0.600000
150
Annexes
Les fonctions logarithmiques et exponentielles

Exp(x) Exp(X) fonction exponentielle Exp(0) = 1
Ln(x) Log(X) logarithme népérien de x s’il Log(10) = 1
est positif
log10(X) Log10(X) logarithme à base 10 Log10(200,000000) = 2,301030
Frexp(double x, décompose x en une fraction Frexp(0.625000, 4) = 0.625000

int *y) normalisée (représentée par la * 2 ^ 4 = 10,000000
valeur de retour) et une
puissance entière de 2^ y. Si x
= 0, les deux parties du
résultat valent 0
ldexp(double x, renvoie x multiplié par 2^y ldexp(0.500000, 2) = 0.500000
int y) * 2 ^ 2 = 2.000000
151
Annexes
Les fonctions portant sur les chaînes
Nom En C Rôle Bibliothèque Exemple
Strcat(ch1, recopie la seconde chaîne Ch1 = “Langage”
ch2) ch2 à la suite de la première Ch2 = “ de
ch1 #include Programmation”
<String.h> Ch = Strcat(Ch1, Ch2)
➔ Ch = “Langage de
Concat(ch1
programmation”
, ch2)
Strncat(ch1, travaille de la même façon Ch = Strncat(Ch1, Ch2,
ch2, lgmax) que Strcat en offrant un 6)
#include
contrôle sur le nombre de ➔Ch = "Langage de
<String.h>
caractères qui seront Pr"
concaténés de la chaine ch2.
152
Annexes
Strcmp(ch1, compare deux chaînes et fournit Strcmp("aa", "aa") →

ch2) une valeur entière positive si ch1 > #include égal
ch2, nulle si ch1= ch2 et négative <String.h>
si ch1< ch2.
Strncmp(ch1, travaille comme Strcmp mais elle Strncmp("aabb", "aaaa",
#include
ch2, lgmax) limite la comparaison au nombre 2) → égal
<String.h>
lgmax de caractères.
Stricmp (ch1, travaillent comme Strcmp et Stricmp("aa", "AA") →
ch2) Strncmp mais sans tenir compte égal
#include
et de la différence entre majuscules Strnicmp("aAbb",
<String.h>
Strnicmp(ch1, et minuscules. "Aaaa", 2) → égal
ch2, lgmax)
153
Annexes
Strchr(ch, recherche dans ch, la première Strchr(première, e)
#include
caractère) position où apparait le caractère →3
<String.h>
mentionné.
Strrchr(ch, opère de même mais en #include Strrchr(première, e)
caractère) partant de la fin de ch <String.h> →8
Strcspn(ch, recherche la première occurrence str = "fcba73" ;
caractère) dans une chaîne, de l’un des touch =
caractères d’une seconde chaîne. #include "1234567890" ;
<String.h> i = strcspn (str,
touch);
Pos(ch1, ➔i = 5
caractère) Strspn(ch, recherche dans str1 la position du strT = "129e" ;
caractère) premier caractère n’ayant pas cset =
d’équivalent dans str2 et renvoie #include "1234567890" ;
cette position, ou NULL si aucune <String.h> i = strspn (strT,
correspondance n’est découverte. cset);
➔i = 3
Strpbrk(str recherche la première occurrence, str1 = "ae2fi3jk4l";
1, str2) dans une chaîne, d’un des str2 = "34" ;
caractères d’une seconde chaîne ; #include ret = strpbrk ( str1 ,
mais, en plus, elle inclut le <String.h> str2 );
terminateur \0 dans la recherche. ➔ret = "3" 154
Annexes
fournit en résultat la Ch1=

longueur d’une chaîne #include "informatique"
Long(ch) Strlen(char)
dont on lui a transmis <String.h> L = Strlen (Ch1)
l’’adresse en valeur. Donc L = 12
Strcpy recopie la chaîne source Ch1 = "Bonjour"
#include
(destin, dans l’emplacement Strcpy(Ch2, Ch1) ;
<String.h>
Sous- source) d’adresse destin. ➔Ch2 = "Bonjour"
chaîne Strncpy(des limite la copie au nombre Strncpy(Ch2, Ch1,
(Ch1, Ch2, tin, de caractères lgmax. #include 3) ;
n) source, <String.h> ➔Ch2 = "Bon"
lgmax)
155
Annexes
Pos(ch1, Strstr(ch, recherche dans ch la a ="Just some

ch2) ssch) première occurrence de la random string";
sous chaîne ssch. b = strstr (a,"string");
#include
➔ b = “String”
<String.h>
c = strstr
(a,"wrong");
➔ c = NULL
Tolwr(char) convertit le caractère fourni Tolwr("BONJOUR")
include
en argument de majuscules ➔ bonjour
<Ctype.h>
en minuscules
Majus(c) Toupr(char) convertit le caractère fourni Toupr("bonjour")
include
en argument de minuscules ➔ BONJOUR
<Ctype.h>
en majuscules
156
Annexes
Strtol(ptr, convertit une chaîne de Strol ("a100", NULL, 10)

endptr, base) caractères en une valeur de →0
En cas de base type long int Strol ("100", NULL, 10)
10 include → 100
Strtol(ch, NULL, <Ctype.h> Strol ("+50x », NULL, 10)
10) → 50
Strol (" 125", NULL, 10)
→ 125
Valeur(ch, Strtoll(ptr, même travail mais la valeur de include
d, erreur) endptr, base) type long long int <Ctype.h>
Strtoul(ptr, même travail mais la valeur de include
endptr, base) type unsigned long int <Ctype.h>
Strtoull(ptr, même travail mais la valeur de
endptr, base) type unsigned long long int
Strtod(ptr, même travail mais la valeur de "12" → 12.000000
endptr, base) type double " 0.123" → 0.123000
"125E+3" →
123000.000000
"123.1e 5" → 0.001231
Strtof(ptr, même travail mais la valeur de
endptr, base) type float
157
Annexes
Les fonctions de test de caractères
Leurs prototypes se trouvent dans le fichier d’en-tête ctype.h (#include
<ctype.h>). Toutes renvoient un résultat de type booléen (vrai ou faux).
En C Rôle Exemple
isalnum(int ch) Renvoie vrai si ch est une lettre ou var1 = 'd' ; var2 = '2 ' ; var3 = '\ t' ; var4 =
un chiffre " '';
isalnum(var1)→ vrai /* d : alphanumérique
isalnum(var2)→ vrai /* 2 : alphanumérique
isalnum(var3)→ faux / * \t : pas
alphanumérique
isalnum(var4)→ faux /* " " : pas
alphanumérique
isalpha(int ch) Renvoie vrai si ch est une lettre isalpha(var1)→ vrai /* d : alphabet
isalpha(var2)→ vrai /* 2 : alphabet
isalpha(var3)→ faux / * \t : pas alphabet
isalpha(var4)→ faux /* " " : pas alphabet
isascii() Renvoie vrai si ch est un caractère
ASCII standard (compris entre 0 et
127)
iscntrl( int ch) Renvoie vrai si ch est un caractère
de contrôle
ASCII, ces caractères ont des codes
octaux de 000 à 037, et 177 (DEL). 158
Annexes
isdigit(int Renvoie vrai si ch est un chiffre isdigit(var1)→ faux /* d : pas chiffre
ch) isdigit(var2)→ vrai /* 2 : chiffre
isgr Renvoie vrai si ch est un caractère isgraph(var1)→ vrai /* d : imprimé
aph(int ch) imprimable (autre qu’un espace) isgraph (var2)→ vrai /* 2 : imprimé
isgraph (var4)→ faux /* " " : pas imprimé
islo Renvoie vrai si ch est une lettre var5 = 'D' ;
wer(int ch) minuscule (bas de casse) islower(var1)→ vrai /* d : minuscule
islower (var2)→ faux /* 2 : pas minuscule
islower(var5)→ faux /* D : pas minuscule
isprint (int Renvoie vrai si ch est un caractère isprint(var1)→ vrai /* d : imprimé
ch) imprimable (espace compris) isprint (var2)→ vrai /* 2 : imprimé
isprint (var3)→ faux / * \t : pas imprimé
isprint (var4)→ vrai /* " " : imprimé
159
Annexes
ispunct (int Renvoie vrai si ch est un caractère Var6 = '/' ;

ch) de ponctuation ispunct(var1)→ faux /* d : pas un caractère de
ponctuation
ispunct (var2)→ faux /* 2 : pas un caractère de
ponctuation
ispunct (var6)→ vrai /* / : un caractère de
ponctuation
isspace (int Renvoie vrai si ch est un séparateur isspace(var1)→ faux /* d : pas un espace
ch) (espace, tabulation, tabulation blanc
verticale, à la ligne, saut de page isspace (var2)→ faux /* 2 : pas un espace
ou retour chariot) blanc
isspace(var4)→ vrai /* " " : un espace blanc
isupper (int Renvoie vrai si ch est une lettre isupper(var1)→ faux /* d : pas majuscule
ch) majuscule (capitale) isupper (var2)→ faux /* 2 : pas majuscule
isupper(var5)→ vrai /* D : majuscule
isxdigit (int Renvoie vrai si ch est un chiffre Var7 = "Tuts" ; var8 = "0E" ;
ch) hexadécimal (0 à 9 et A à F) isxdigit(var7)→ faux /* Tuts : pas caractère
hexadécimal
isxdigit(var8)→ vrai /* 0E : caractère
hexadécimal
160
Annexes
Les fonctions relatives au temps
La bibliothèque standard contient un certain nombre de fonctions relatives au

temps. Leurs prototypes se trouvent dans le fichier d’en-tête time.h (#include
<time.h>).
En C Rôle Exemple
mktime( struct tm () convertit la structure int main (void)
pointée par tm en une { struct tm time_info;
valeur de time_t selon time_t time_raw_format;
le fuseau horaire local. time_info.tm_year = 2008-1900;
time_info.tm_mon = 0;
time_info.tm_mday = 1;
time_info.tm_hour = 0;
time_info.tm_min = 0;
time_info.tm_sec = 1;
time_info.tm_isdst = 0;
time_raw_format = mktime (et time_info);
printf (ctime (& time_raw_format));
retourner 0; }
➔Mardi 1er janvier 2008 0:00:01
161
Annexes
ctime(const time_t) retourne une chaîne de C time_t curtime ;

contenant la date et l'heure ctime (& curtime );
dans un format lisible par ➔jeudi 06 février
l'homme. 2014 10:23:14
asctime(const struct tm ) envoie un pointeur vers une int principale ()
chaîne qui représente le jour { struct tm t ;
et l'heure de la structure tm t . tm_sec = 10 ;
t . tm_min = 10 ;
t . tm_hour = 6 ;
t . tm_mday = 25 ;
t . tm_mon = 2 ;
t . tm_year = 89 ;
t . tm_wday = 6 ;
puts(asctime(& t));
retour ( 0 ); }
➔Sam. 25 mars 1989
6:10:10
162
Annexes
time( time_t) Donne le temps

courant tel qu’il est
maintenu par l’horloge
interne de votre
ordinateur
localtime(struct tm ) récupérer la date et Information = localtime (& t );
heure courante selon
la structure tm
difftime(time_t calculer la différence diff_t = difftime ( 12 :25 :30 ,
temps1, time_t entre deux valeurs de 12 :30 :30 );
time2) type ➔diff_t = 300
time t et renvoie leur
différence comme une
valeur double
163

Algorithme Et Programation C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algorithme Et Programation C

Transféré par

Droits d'auteur :

Formats disponibles

Cours d’Algorithmique et Programmation en Langage C

A. Yengui && A. Zouch

LAPHY1 / LGBM1 (S2)

Les bases de la programmation

Qu’est-ce qu’un algorithme?

Donc, un algorithme se termine en un temps ﬁni.

Le langage algorithmique choisi doit être simple, clair et précis.

Nous utiliserons un langage francisé formé d’une vingtaine de

Les bases de la programmation

Mots réservés du langage algorithmique

On y ajoutera des fonctions utiles, par exemple : Alea(n), qui

Les bases de la programmation

Mots réservés du langage C (norme ANSI C99)

Les bases de la programmation

Un programme est destiné à l’être humain. Pour en faciliter la

Les bases de la programmation

La présentation des programmes

Les bases de la programmation

Les bases de la programmation

Les bases de la programmation

• short int ou short (entier sur 16 bits : - 32 768 à 32 767)

Exemple: unsigned short x; x peut aller de 0 à 65 535

Les bases de la programmation

Les bases de la programmation

• Float : codé sur 4 octets avec 1 bit de signe, 23 bits de

- C accepte les constantes flottante en notation décimale ou

Ensemble de déﬁnition : la table ASCII

Notation algorithmique : c1,c2 : caractère

Notation C : char c1, c2;

Les bases de la programmation

Taille et amplitude du type caractère

La table ASCII code tous les caractères usuels (états-uniens) sur 7

Les bases de la programmation

Les bases de la programmation

• Un tableau (array) est une collection de variables de même

Les bases de la programmation

le compilateur réserve SIZE places en mémoire pour

float A[5] = { 10.1, 20.3, 30.5, 40.0, 50.4 };

• Les éléments sont numérotés de 0 à dim-1 !

Les tableaux consomment beaucoup de place mémoire. On

Les bases de la programmation

Un nom de variable représente une et une seule valeur qui peut

Déclaration algorithmique : tension,puissance : ﬂottant

Les bases de la programmation

Une constante doit toujours recevoir une valeur dès sa

Les bases de la programmation

TYPE de la valeur de retour

"main" : Cela signifie "principale",

Les bases de la programmation

Dans une aﬀectation, le membre de gauche reçoit le membre de

Exemple: printf("leur somme est : %d",n1+n2);

• c : char: caractère affiché ''en clair" (convient aussi à short

Les possibilités de la fonction printf

Les possibilités de la fonction printf

Les possibilités de la fonction printf

Erreur 1 : Code de format en désaccord avec le type de

Conséquence : mauvaise interprétation si même taille (int

Conséquence 1 : si des expressions de la liste n’ont pas de

Conséquence 2 : s’il y a trop de code de format, printf

Les possibilités de la fonction scanf

Les possibilités de la fonction scanf

Les premières règles utilisées par scanf :

Exemples : (n et p sont de type int, c char, @ désigne une

puts puts(char s); Ecriture/Lecture d'une

sscanf sscanf(char s, char format, Lit la chaîne d'adresse