Le Langage C

Année universitaire 2020/2021

2020/2021
Plan du cours (1)

1. Introduction

2. Types, opérateurs et expressions

3. Les entrées-sorties (printf, scanf,

…)

4. Les structures de contrôle

5. Les tableaux 2
Plan du cours (2)

6. Les pointeurs

7. Les fonctions

8. Les chaînes de
caractères

9. Les structures

3
Langages informatiques
 Un langage informatique est un outil permettant de
donner des ordres (instructions) à la machine

• A chaque instruction correspond une action du

processeur

 Intérêt : écrire des programmes (suite consécutive

d’instructions) déstinés à effectuer une tache donnée

• Exemple: un programme de gestion de comptes bancaires

 Contrainte: être compréhensible par la machine

4
Langage machine
 Langage binaire: l’information est exprimée et manipulée
sous forme d’une suite de bits

 Un bit (binary digit) = 0 ou 1 (2 états électriques)

 Une combinaison de 8 bits= 1 Octet  28 

256 possibilités qui permettent
de coder tous les caractères alphabétiques, numériques, et symboles tels que ?,*,&, …

• Le code ASCII (American Standard Code for Information Interchange) donne les
correspondances entre les caractères alphanumériques et leurs
représentation binaire, Ex. A= 01000001, ?=00111111

 Les opérations logiques et arithmétiques de base

(addition, multiplication, … ) sont effectuées en binaire

5
L'assembleur
 Problème: le langage machine est difficile à comprendre par l'humain

 Idée: trouver un langage compréhensible par l'homme qui sera

ensuite converti en langage machine
• Assembleur : exprimer les instructions élémentaires de façon
symbolique
ADD A, 4
traducteur langage machine
LOAD B
MOV A, OUT
• +: déjà plus accessible que le langage machine
• -: dépend du type de la machine (n’est pas portable)
• -: pas assez efficace pour développer des applications complexes

Apparition des langages évolués

6
Langages haut niveau
 Intérêts multiples pour le haut niveau:
• proche du langage humain «anglais» (compréhensible)
• permet une plus grande portabilité (indépendant du
matériel)
• Manipulation de données et d’expressions complexes
(réels, objets, a*b/c, …)
 Nécessité d’un traducteur (compilateur/interpréteur),
exécution plus ou moins lente selon le traducteur
Code source Compilateur ou
Langage machine
en langage évolué interpréteur

7
Compilateur/interpréteur
 Compilateur: traduire le programme entier une fois pour
toutes
Compilateur exécution
exemple.c exemple
fichier source fichier exécutable
• + plus rapide à l’exécution
• + sécurité du code source
• - il faut recompiler à chaque modification

 Interpréteur: traduire au fur et à mesure les instructions

du programme à chaque exécution
Interprétation+exécution
exemple.bas
fichier source
• + exécution instantanée appréciable pour les débutants
• - exécution lente par rapport à la compilation
8
Langages de
programmation:

 Deux types de langages:

• Langages procéduraux
• Langages orientés objets

 Exemples de langages:
• Fortran, Cobol, Pascal, C, …
• C++, Java, …

2011/2012
Historique du C
 Le langage C a été conçu en 1972 dans «Bell Laboratories » par
Dennis Ritchie avec l’objectif d’écrire un système d'exploitation
(UNIX).

 En 1978, une première définition rigoureuse du langage C (standard

K&R-C) a été réalisée par Kernighan et Ritchie en publiant le
livre
«The C Programming Language ».

 Le succès du C et l’apparition de compilateurs avec des extensions

particulières ont conduit à sa normalisation.

 En 1983, l’organisme ANSI (American National Standards Institute)

chargeait une commission de mettre au point une définition explicite
et portable pour le langage C. Le résultat est le standard ANSI-C.

2011/2012
 Caractéristiques du C
 Universel : n'est pas orienté vers un domaine d'application particulier
(applications scientifiques, de gestion, …)

 Près de la machine : offre des opérateurs qui sont proches de ceux du

langage machine (manipulations de bits, d’adresses, …)  efficace

 Modulaire: peut être découpé en modules qui peuvent être compilés

séparément

 Portable: en respectant le standard ANSI-C, il est possible d'utiliser le

même programme sur plusieurs systèmes (hardware, système
d'exploitation )

Remarque : Une programmation efficace et compréhensible en C n'est pas

facilement accessible à des débutants

2011/2012
 Programme source, objet et exécutable
 Un programme écrit en langage C forme un texte qu’on nomme
programme ou code source, qui peut être formé de plusieurs fichiers
sources

 Chaque fichier source est traduit par le compilateur pour obtenir un

fichier ou module objet (formé d’instructions machine)

 Ce fichier objet n’est pas exécutable tel quel car il lui manque les
instructions exécutables des fonctions standards appelées dans le fichier
source (printf, scanf, …) et éventuellement d’autres fichiers objets

 L’éditeur de liens réunit les différents modules objets et les fonctions

de la bibliothèque standard afin de former un programme exécutable

Remarque : la compilation est précédée par une phase de prétraitement

(inclusion de fichiers en-tête) réalisé par le préprocesseur
 Compilateurs C
 Pour pouvoir écrire des programmes en C, vous avez besoin
d’un compilateur C sur votre machine

 Il existe plusieurs compilateurs respectant le standard ANSI-C.

Une bonne liste est disponible sur :
c.developpez.com/compilateurs/

 Et l'environnement de développement Dev-C++ avec le

système d’exploitation Windows

 Vous pouvez télécharger Dev-C++ librement, par exemple sur le sit

www.bloodshed.net
 https://sourceforge.net/projects/orwelldevcpp/files/latest/download
Exemple d’une fenêtre Dev-C++
 Code Blocks

Accédez à ce lien:
http://www.codeblocks.org/downloads/26
https://
www.fosshub.com/Code-Blocks.html?dwl=codeblocks-20.03-setup.
exe

ou bien
https://
code-blocks.fr.uptodown.com/windows/telecharger
Il faut choisir la version qui inclut le compilateur
Composantes d’un
programme C
• Directives du préprocesseur
• inclusion des fichiers d'en-tête (fichiers avec extension .h)
• définitions des constantes avec #define

• déclaration des variables globales

• définition des fonctions (En C, le programme principal et les sous-
programmes sont définis comme fonctions )

• Les commentaires : texte ignoré par le compilateur, destiné à

améliorer la compréhension du code
exemple : #include<stdio.h>
main()
{
printf( "notre premier
programme
C \n");
/*ceci est un
commentaire*
/
Remarques sur ce premier
programme
 #include<stdio.h> informe le compilateur d’inclure le fichier stdio.h qui
contient les fonctions d’entrées-sorties dont la fonction printf

 La fonction main est la fonction principale des programmes en C: Elle se

trouve obligatoirement dans tous les programmes. L'exécution d'un
programme entraîne automatiquement l'appel de la fonction main.

 L’appel de printf avec l’argument "notre premier programme C\n" permet

d’afficher : notre premier programme C et \n ordonne le passage à la
ligne suivante

 En C, toute instruction simple est terminée par un point-virgule ;

 Un commentaire en C est compris entre // et la fin de la ligne ou

bien entre /* et */
Le Langage C

Année universitaire 2018/2019

2011/2012
Chapitre 2
 Variables, types, opérateurs et
expressions

2011/2012
Les variables
 Les variables servent à stocker les valeurs des données
utilisées pendant l’exécution d’un programme

 Les variables doivent être déclarées avant d’être

utilisées, elles doivent être caractérisées par :

• un nom (Identificateur)
• un type (entier, réel, …)
(Les types de variables en C seront discutés par la suite)

2011/2012
Les identificateurs
Le choix d’un identificateur (nom d’une variable ou d’une fonction) est
soumis à quelques règles :

 doit être constitué uniquement de lettres, de chiffres et du caractère

souligné _ (Eviter les caractères de ponctuation et les espaces)
correct: PRIX_HT, prixHT incorrect: PRIX-HT, prix HT, prix.HT

 doit commencer par une lettre (y compris le caractère souligné)

correct : A1, A1 incorrect: 1A

 doit être différent des mots réservés du langage : auto break case char
const continue default do double else enum extern float for goto
if int long register return short signed sizeof static
struct switch typedef union unsigned void volatile while

Remarque : C distingue les majuscules et les minuscules. NOMBRE et nombre

sont des identificateurs différents

2011/2012
Les types de base
 Le type d’une variable détermine l’ensemble des valeurs qu’elle peut prendre
et le nombre d'octets à lui réserver en mémoire

 En langage C, il n’y a que deux types de base les entiers et les réels avec
différentes variantes pour chaque type
Remarques:
 Un type de base est un type pour lequel une variable peut prendre une seule
valeur à un instant donné contrairement aux types agrégés

 Le type caractère apparaît en C comme cas particulier du type entier (un

caractère est un nombre entier, il s’identifie à son codeASCII)

 En C il n'existe pas de type spécial pour chaînes de caractères. Les moyens

de traiter les chaînes de caractères seront présentés aux chapitres suivants

 Le type booléen n’existe pas. Un booléen est représenté par un entier (un
entier non nul équivaut à vrai et la valeur zero équivaut à faux)

2011/2012
 Types Entier
4 variantes d’entiers :
 char : caractères (entier sur 1 octet : - 128 à 127)
 short ou short int : entier court (entier sur 2 octets : - 32768 à 32767)
 int : entier standard (entier sur 2 ou 4 octets )
 long ou long int : entier long (4 octets : - 2147483648 à 2147483648)

Si on ajoute le préfixe unsigned à la définition d'un type de variables

entières, alors la plage des valeurs change:
 unsigned char : 0 à 255
 unsigned short : 0 à 65535
 unsigned int : dépend du codage (sur 2 ou 4 octets)
 unsigned long : 0 à 4294967295

Remarque : Une variable du type char peut subir les mêmes opérations que les
variables du type short, int ou long

2011/2012
 Types Réel
3 variantes de réels :

 float : réel simple précision codé sur 4 octets de

-3.4*1038 à 3.4*1038
 double : réel double précision codé sur 8 octets de
-1.7*10308 à 1.7*10308
 long double : réel très grande précision codé sur 10
octets de -3.4*104932 à 3.4*104932

2011/2012
Déclaration des variables
 Les déclarations introduisent les variables qui seront utilisées,
fixent leur type et parfois aussi leur valeur de départ (initialisation)

 Syntaxe de déclaration en C

<Type> <NomVar1>,<NomVar2>,...,<NomVarN>;
 Exemple:
int i, j,k;
float x, y ;
double z=1.5; // déclaration et initialisation
short compteur;
char c=`A`;

2011/2012
 Déclaration des constantes
 Une constante conserve sa valeur pendant toute l’exécution d’un programme

 En C, on associe une valeur à une constante en utilisant:

• la directive #define :
#define nom_constante valeur
Ici la constante ne possède pas de type.
exemple: #define Pi 3.141592

• le mot clé const :

const type nom = expression ;
Dans cette instruction la constante est typée
exemple : const float Pi =3.141592

(Rq: L’intérêt des constantes est de donner un nom parlant à une valeur, par exemple
NB_LIGNES, aussi ça facilite la modificationdu code)

2011/2012
 Constantes entières
On distingue 3 formes de constantes entières :

 forme décimale : c’est l’écriture usuelle. Ex : 372, 200

 forme octale (base 8) : on commence par un 0 suivi de chiffres

octaux. Ex : 0477

 forme hexadécimale (base 16) : on commence par 0x (ou 0X) suivis

de chiffres hexadécimaux (0-9 a-f). Ex : 0x5a2b, 0Xa9f

2011/2012
 Remarques sur les constantes entières
 Le compilateur attribue automatiquement un type aux constantes
entières. Il attribue en général le type le plus économique parmi (int,
unsigned int, long int, unsigned long int)

 On peut forcer la machine à utiliser un type de notre choix en

ajoutant les suffixes suivants:

• u ou U pour unsigned int, Ex : 100U, 0xAu

• l ou L pour long, Ex : 15l, 0127L
• ul ou UL pour unsigned long, Ex : 1236UL, 035ul

2011/2012
 Constantes réelles
On distingue 2 notations :
 notation décimale Ex : 123.4, .27, 5.

 notation exponentielle Ex : 1234e-1 ou 1234E-1

Remarques :
 Les constantes réelles sont par défaut de type double

 On peut forcer la machine à utiliser un type de notre choix en ajoutant

les suffixes suivants:

• f ou F pour le type float, Ex: 1.25f

• l ou L pour le type long double, EX: 1.0L

2011/2012
 Les constantes caractères
 Se sont des constantes qui désignent un seul caractère,
elles sont toujours indiquées entre des apostrophes, Ex :
‘b’, ‘A’, ‘?’

 La valeur d’une constante caractère est le code ASCII du

caractère

 Les caractères constants peuvent apparaître dans des

opérations arithmétiques ou logiques

 Les constantes caractères sont de type int

2011/2012
Expressions et opérateurs
 Une expression peut être une valeur, une variable ou une opération
constituée par des valeurs, des constantes et des variables reliées
entre eux par des opérateurs
exemples: 1, b, a*2, a+ 3*b-c, …
 Un opérateur est un symbole qui permet de manipuler une ou
plusieurs variables pour produire un résultat. On distingue :

• les opérateurs binaires qui nécessitent deux opérandes (ex : a +b)

• les opérateurs unaires qui nécessitent un seul opérande ( ex:a++)
• l'opérateur conditionnel ?: , le seul qui nécessite troisopérandes

 Une expression fournit une seule valeur, elle est évaluée en

respectant des règles de priorité et d’associativité

2011/2012
Opérateurs en C
 Le langage C est riche en opérateurs. Outre les opérateurs
standards, il comporte des opérateurs originaux d’affectation,
d’incrémentation et de manipulation de bits

 On distingue les opérateurs suivants en C :

• les opérateurs arithmétiques : +, -, *, /, %

• les opérateurs d’affectation : =, +=, -=,*=,/=,…
• les opérateurs logiques : &&, ||, !
• les opérateurs de comparaison : ==, !=, <, >, <=, >=
• les opérateurs d’incrémentation et de décrémentation : ++, --
• les opérateurs sur les bits : <<, >>, &, |, ~, ^
• d’autres opérateurs particuliers : ?:, sizeof, cast

2011/2012
 Opérateurs arithmétiques
 binaires : + - * / et % (modulo) et unaire : -

 Les opérandes peuvent être des entiers ou des réels sauf pour % qui
agit uniquement sur des entiers

 Lorsque les types des deux opérandes sont différents il y’a conversion
implicite dans le type le plus fort

 L’opérateur / retourne un quotient entier si les deux opérandes sont des

entiers (5 / 2  2). Il retourne un quotient réel si l’un au moins des
opérandes est un réel (5.0 / 2  2.5)

2011/2012
Conversions implicites
 Les types short et char sont systématiquement convertis en int
indépendemment des autres opérandes

 La conversion se fait en général selon une hiérarchie qui

n'altère pas les valeurs int  long  float  double  long double

 Exemple1 : n * x + p (int n,p; float x)

• exécution prioritaire de n * x : conversion de n en float
• exécution de l'addition : conversion de p en float

 Exemple2 : p1 * p2 + p3 * x (char p1, short p2, p3 ; float x)

• p1, p2 et p3 d'abord convertis en int
• p3 converti en float avant multiplication

2011/2012
Exemple de conversion
Exemple : n * p + x (int n ; long p ; float x)

n * p + x

long conversion de n en long

* multiplication par p

long n * p de type long

float conversion de n * p en float

+ addition

float résultat de type float

2011/2012
 Opérateur d’affectation simple =
 L’opérateur = affecte une valeur ou une expression à une variable
• Exemple: double x,y,z; x=2.5; y=0.7; z=x*y-3;
 Le terme à gauche de l’affectation est appelé lvalue (left value)

 L'affectation est interprétée comme une expression. La valeurde

l'expression est la valeur affectée

 On peut enchainer des affectations, l’évaluation se fait de droite à gauche

• exemple : i = j = k= 5 (est équivalente à k = 5, j=k et ensuite i=j)
 La valeur affectée est toujours convertie dans le type de la lvalue, même si
ce type est plus faible (ex : conversion de float en int, avec perte
d'information)

2011/2012
Opérateurs relationnels
 Opérateurs
• < : inférieur à <= : inférieur ou égal à
• > : supérieur à >= : supérieur ou égal à
• == : égal à != : différent de

 Le résultat de la comparaison n’est pas une valeur booléenne,

mais 0 si le résultat est faux et 1 si le résultat est vrai

 Les expressions relationnelles peuvent donc intervenir dans

des expressions arithmétiques

 Exemple: a=2, b=7, c=4

• b==3  0 (faux)
• a!=b  1(vrai)
• 4*(a<b) + 2*(c>=b) 4

2011/2012
 Opérateurs logiques
 && : ET logique || : OU logique ! : négation logique

 && retourne vrai si les deux opérandes sont vrais (valent 1) et 0 sinon

 || retourne vrai si l’une des opérandes est vrai (vaut 1) et 0 sinon

 Les valeurs numériques sont acceptées : toute valeur non nulle

correspond à vraie et 0 correspond à faux

• Exemple : 5 && 11  1
!13.7  0

2011/2012
 Évaluation de && et ||
 Le 2ème opérande est évalué uniquement en cas de nécessité
• a && b : b évalué uniquement si a vaut vrai (si a vaut faux,
évaluation de b inutile car a && b vaut faux)
• a b : b évalué uniquement si a vaut faux (si a vaut vrai,
évaluation de b inutile car a  b vaut vrai)

 Exemples
• if ((d != 0) && (n / d == 2)) : pas de division si d vaut 0
• if ((n >=0) && (sqrt(n) < p)) : racine non calculée si n < 0
 L’intérêt est d’accélérer l’évaluation et d’éviter les traitements
inappropriés

2011/2012
 Incrémentation et décrémentation

 Les opérateurs ++ et -- sont des opérateurs unaires permettant respectivement d'ajouter

et de retrancher 1 au contenu de leur opérande
 Cette opération est effectuée après ou avant l'évaluation de l'expression suivant que
l'opérateur suit ou précède son opérande
• k = i++ (post-incrémentation) affecte d'abord la valeur de i à k et incrémente après (k
= i++ ;  k = i ; i = i+1 ; )

• k = ++i (pré-incrémentation) incrémente d'abord et après affecte la valeur incrémentée

à k (k = ++i ;  i = i+1 ; k = i ; )

 Exemple : i = 5 ; n = ++i - 5 ;
i vaut 6 et n vaut 1
i = 5 ; n = i++ - 5 ;
i vaut 6 et n vaut 0

 Remarque : idem pour l’opérateur de décrémentation --

2011/2012
Opérateurs de manipulations de bits

 opérateurs arithmétiques bit à bit :

& : ET logique | : OU logique ^ : OU exclusif ~ : négation

 Les opérandes sont de type entier. Les opérations s'effectuent bit à bit
suivant la logique binaire

b1 b2 ~b1 b1&b2 b1 | b2 b1^b2

1 1 0 1 1 0
1 0 0 0 1 1
0 1 1 0 1 1
0 0 1 0 0 0

 Ex : 14= 1110 , 9=1001 14 & 9= 1000=8, 14 | 9 =1111=15

2011/2012
 Opérateurs de décalage de bits

 Il existe deux opérateurs de décalage :

 >> : décalage à droite << : décalage à gauche

 L’opérande gauche constitue l’objet à décaler et l’opérande

droit le nombre de bits de décalage

 Dans le cas d'un décalage à gauche les bits les plus à gauche
sont perdus. Les positions binaires rendues vacantes sont
remplies par des 0
 Ex : char x=14; (14=00001110)  14<<2 = 00111000
= 56
 char y=-7; (-7=11111001)  -7<<2= 11100100= -28

 Rq : un décalage à gauche de k bits correspond

(sauf débordement) à la multiplication par 2k

2011/2012
Opérateurs de décalage de bits

 Lors d'un décalage à droite les bits les plus

à droite sont perdus.
• si l'entier à décaler est non signé, les positions binaires rendues
vacantes sont remplies par des 0

• s'il est signé le remplissage dépend de l’implémentation(en général le

remplissage se fait par le bit du signe)

 Ex : char x=14; (14=00001110) 

14>>2 = 00000011 = 3
 Remarque : un décalage à droite (n >> k) correspond à la division
entière par 2k si n est non signé

2011/2012
 Opérateurs d’affectation combinés

 Soit un opérateur de calcul op et deux expressions exp1 et exp2.

L’expression exp1= exp1 op exp2 peut s’écrire en général de
façon équivalente sous la forme exp1 op= exp2

 Opérateurs utilisables :
• += -= *= /= %=
• <<= >>= &= ^= |=

 Exemples :
• a=a+b s’écrit : a+=b
• n=n%2 s’écrit : n%=2
• x=x*i s’écrit : x*=i
• p=p>>3 s’écrit : p>>=3

2011/2012
Opérateur de forçage de type (cast)

 Il est possible d’effectuer des conversions explicites ou de

forcer le type d’une expression
• Syntaxe : (<type>) <expression>
• Exemple : int n, p ;
(double) (n / p); convertit l’entier n / p en double

 Remarque : la conversion (ou casting) se fait après calcul

(double) (n/p)  (double) n / p  (double) (n) / (double) (p)

• float n = 4.6, p = 1.5 ;

(int) n / (int) p = 4 / 1 = 4
(int) n / p = 4 / 1.5 = 2.66
n / (int) p = 4.6 / 1 = 4.6
n / p = 4.6 / 1.5 = 3.06

2011/2012
Opérateur conditionnel ? :
 Syntaxe: exp1 ? exp2 : exp3
exp1 est évaluée, si sa valeur est non nulle c’est exp2
qui est exécutée, sinon exp3

 Exemple1 : max = a > b ? a : b

Si a>b alors on affecte à max le contenu de exp2 càd a sinon
on lui affecte b

 Exemple2 : a>b ? i++ : i--;

Si a>b on incrémente i sinon on décrémente i

2011/2012
 Opérateur séquentiel ,
 Utilité : regrouper plusieurs sous-expressions ou calculs en une seule
expression

 Les calculs sont évalués en séquence de gauche à droite

 La valeur de l’expression est celle de la dernière sous-expression

 Exemples
• i++ , i + j; // on évalue i++ ensuite i+j (on utilise la valeur de i incrémentée)
• i++ , j = i + k , a + b; // la valeur de l’expression est celle de a+b
• for (i=1 , k=0 ; … ; …) { }

2011/2012
 Opérateur SIZEOF
 Syntaxe : sizeof (<type>) ou sizeof (<variable>)
fournit la taille en octets d'un type ou d'une variable

 Exemples
• int n;
• printf ("%d \n",sizeof(int)); // affiche 4
• printf ("%d \n",sizeof(n)); // affiche 4

2011/2012
 Priorité et associativité des opérateurs
 Une expression est évaluée en respectant des règles de priorité et
d’associativité des opérateurs
• Ex: * est plus prioritaire que +, ainsi 2 + 3 * 7 vaut 23 et non 35

 Le tableau de la page suivante donne la priorité de tous les opérateurs.

La priorité est décroissante de haut en bas dans le tableau.

 Les opérateurs dans une même ligne ont le même niveau de priorité.
Dans ce cas on applique les règles d’associativité selon le sens de la
flèche. Par exemple: 13%3*4 vaut 4 et non 1

 Remarque: en cas de doute il vaut mieux utiliser les parenthèses pour

indiquer les opérations à effectuer en priorité. Ex: (2 + 3) * 7 vaut 35

2011/2012
Priorités de tous les opérateurs

Catégorie Opérateurs Associativité

référence () [ ] -> . **************
unaire ++ - - ! ~ *************
arithmétique */ % ************
arithmétique + - ***********
décalage << >> **********
relationnel < <= > >= *********
relationnel == != ********
manip. de bits & *******
manip. de bits ^ ******
manip. de bits | *****
logique && ****
logique | ***
conditionnel ?: **
affectation = += -= *= /= %= &= ^= *
|= <<= >>=

2011/2012
2011/2012
 2011/2012

CHAPITRE 3

Entrées-sorties
 LES INSTRUCTIONS DE LECTURE ET
D’ÉCRITURE
 Il s’agit des instructions permettant à la machine de dialoguer avec
l’utilisateur

• Dans un sens la lecture permet à l’utilisateur d’entrer des valeurs

au clavier pour qu’elles soient utilisées par le programme

• Dans l’autre sens, l’écriture permet au programme de communiquer

des valeurs à l’utilisateur en les affichant à l’écran (ou en les écrivant
dans un fichier)

 La bibliothèque standard <stdio> contient un ensemble de fonctions qui

assurent la lecture et l’écriture des données. Dans ce chapitre, nous allons
en discuter les plus importantes:
• printf() écriture formatée de données
• scanf() lecture formatée de données

2011/2012
 ECRITURE FORMATÉE DE
DONNÉES: PRINTF ()

 la fonction printf est utilisée pour afficher à l’écran du texte,

des valeurs de variables ou des résultats d’expressions.

 Syntaxe : printf("format", expr1, expr2, …);

• expr1,… : sont les variables et les expressions dont les valeurs
sont à représenter
• Format : est une chaîne de caractères qui peut contenir
• du texte
• des séquences d’échappement (‘\n’, ‘\t’,…)
• des spécificateurs de format : un ou deux caractères précédés
du symbole %, indiquant le format d’affichage

Rq : Le nombre de spécificateurs de format doit être égale

au nombre d’expressions!

2011/2012
 SPÉCIFICATEURS DE FORMAT
SYMBOLE TYPE AFFICHAGE COMME
%d ou %i int entier relatif

%u unsinged int entier naturel non signé

%c char caractère

%o int entier sous forme octale

%x ou %X int entier sous forme hexadécimale

%f float, double réel en notation décimale

%e ou %E float, double réel en notation exponentielle

%s char* chaîne de caractères

2011/2012
 SÉQUENCES D’ÉCHAPPEMENT
 l'affichage du texte peut être contrôlé à l'aide des
séquences d'échappement :

• \n : nouvelle ligne
• \t : tabulation horizontale
• \a : signal sonore
• \b : retour arrière
• \r : retour chariot
• \v : tabulation verticale
• \f : saut de page
• \\ : back slash ( \ )
• \’ : apostrophe
• \" : guillemet

2011/2012
 EXEMPLES DE PRINTF()
#include<stdio.h>
main()
{ int i=1 , j=2, N=15;
printf("la somme de %d et %d est %d \n", i, j,
i+j); printf(« N= %x \n" , N);
char c='A' ;
printf(" le code Ascii de %c est %d \n", c, c);
}
Ce programme va afficher la somme de 1 et 2 est
: 3 N=f
le code Ascii de A est
65
Remarque : Pour pouvoir traiter correctement les arguments du type
long, il faut utiliser les spécificateurs %ld, %li, %lu, %lo, %lx

2011/2012
 EXEMPLES DE PRINTF()

#include<stdio.h> main()
{ double x=10.5, y=2.5;
printf("%f divisé par %f égal à %f \n", x, y, x/y); printf("%e divisé par
%e égal à %e\n", x, y, x/y);
}
Ce programme va afficher :
10.500000 divisé par 2.500000 égal à 4.200000
1.050000e+001 divisé par 2.500000e+000 égal à 4.200000e+000

Remarque : Pour pouvoir traiter correctement les arguments du type long double, il faut
utiliser les spécificateurs %lf et %le

2011/2012
 REMARQUES SUR L’AFFICHAGE
 Par défaut, les entiers sont affichés sans espaces avant ou
après

 Pour agir sur l’affichage  un nombre est placé après % et

précise le nombre de caractères minimum à utiliser

 Exemples : printf("%4d" , n );
n = 20  ~~20 (~espace)
n=56123  56123
printf("%4X", 123);  ~~7B

printf("%4x", 123);  ~~7b

2011/2012
 REMARQUES SUR L’AFFICHAGE
 Pour les réels, on peut préciser la largeur minimale de la valeur à afficher
et le nombre de chiffres après le point décimal.
 La précision par défaut est fixée à six décimales. Les positions
décimales sont arrondies à la valeur la plus proche.
 Exemples :
printf("%f", 100.123);  100.123000
printf("%12f", 100.123); 
~~100.123000
printf("%.2f", 100.123);
 100.12
printf("%5.0f", 100.123);
 ~~100
printf("%10.3f",
100.123);  ~~~100.123
printf("%.4f", 1.23456);  1.2346

2011/2012
 LECTURE FORMATÉE DE
DONNÉES: SCANF ()

 la fonction scanf permet de lire des données à partir du clavier

 Syntaxe : scanf("format", AdrVar1, AdrVar2, …);

• Format : le format de lecture de données, est le même que
pour
printf

• adrVar1, adrVar2, … : adresses des variables auxquelles

les données seront attribuées. L’adresse d’une variable
est indiquée par le nom de la variable précédé du signe
&

2011/2012
 EXEMPLES DE SCANF()
#include<stdio.h>
main()
{ int i , j;
scanf("%d%d", &i,
&j);
printf("i=%d et j=%d", i, j);
}

ce programme permet de lire deux entiers entrés au clavier et

les afficher à l’écran.

Remarque : pour lire une donnée du type long, il faut utiliser les
spécificateurs
%ld, %li, %lu, %lo, %lx.
2011/2012
 EXEMPLES DE SCANF()

#include<stdio.h>
main()
{ float x; double y;
scanf("%f %lf", &x, &y); printf("x=%f
et y=%f", x,y);
}

ce programme permet de lire un réel simple et un autre double du clavier

et les afficher à l’écran

Remarque : pour lire une donnée du type double, il faut utiliser %le ou %lf et pour lire une
donnée du type long double, il faut utiliser %Le ou %Lf

2011/2012
Chapitre 4

Structures de contrôle

2011/2012
Structures de contrôle
 Les structures de contrôle définissent la façon avec laquelle les
instructions sont effectuées. Elles conditionnent l'exécution
d'instructions à la valeur d'une expression

 On distingue :
• Les structures alternatives (tests) : permettent d’effectuer des choix
càd de se comporter différemment suivant les circonstances (valeur
d'une expression). En C, on dispose des instructions : if…else et
switch.

• Les structures répétitives (boucles) : permettent de répéter

plusieurs fois un ensemble donné d’instructions. Cette familledispose
des instructions : while, do…while et for.

2011/2012
L’instruction if…else
 Syntaxe : If (expression)
bloc-instruction1
else
bloc-instruction2

• bloc-instruction peut être une seule instruction terminée par un point-

virgule ou une suite d’instructions délimitées par des accolades{ }

• expression est évaluée, si elle est vraie (valeur différente de 0), alors
bloc-instruction1 est exécuté. Si elle est fausse (valeur 0) alors bloc-
instruction2 est exécuté

 La partie else est facultative. S’il n’y a pas de traitement à réaliser

quand la condition est fausse, on utilisera simplement la forme :
If (expression) bloc-instruction1

2011/2012
if…else : exemples
• float a, b, max;
if (a > b)
max = a;
else
max = b;

• int a;
if ((a%2)==0)
printf(" %d est paire" ,a);
else
printf(" a est impaire ",a);

2011/2012
Imbrication des instructions if
 On peut imbriquer plusieurs instructions if…else

 Ceci peut conduire à des confusions, par exemple :

• if (N>0)
if (A>B)
MAX=A;
else MAX=B; (interprétation 1 : si N=0 alors MAX prend la valeur B)

• if (N>0)
if (A>B)
MAX=A;
else MAX=B; (interprétation 2 : si N=0 MAX ne change pas)

 En C un else est toujours associé au dernier if qui ne possède pas

une partie else (c’est l’interprétation 2 qui est juste)

2011/2012
Imbrication des instructions if
 Conseil : pour éviter toute ambiguïté ou pour forcer une certaine
interprétation dans l’imbrication des if, il vaut mieux utiliser les
accolades

 if(a<=0)
{if(a==0)
printf("a est nul ");
else
printf(" a est strictement négatif ");}
else
printf(" a est strictement positif " );

 Pour forcer l’interprétation 1: if (N>0)

{ if (A>B)
MAX=A;
}
else MAX=B;

2011/2012
L’instruction d’aiguillage switch :
 Permet de choisir des instructions à exécuter selon la valeur d’une
expression qui doit être de type entier

 la syntaxe est :
switch (expression) {
case expression_constante1 : instructions_1; break;
case expression_constante2 : instructions_2; break;
…
case expression_constante n : instructions_n; break;
default : instructions;
}
 expression_constantei doit être une expression constante entière
 Instructions i peut être une instruction simple ou composée
 break et default sont optionnels et peuvent ne pas figurer

2011/2012
 Fonctionnement de switch
 expression est évaluée

 si sa valeur est égale à une expression_constante i, on se branche à

ce cas et on exécute les instructions_i qui lui correspondent

• On exécute aussi les instructions des cas suivants jusqu’à la fin du bloc
ou jusqu’à une instruction break (qui fait sortir de la structure switch)

 si la valeur de l'expression n'est égale à aucune des expressions

constantes
• Si default existe, alors on exécute les instructions qui le suivent
• Sinon aucune instruction n’est exécutée

2011/2012
Switch : exemple
main( )
{ char c;
switch (c) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y': printf("voyelle\n"); break ;
default : printf("consonne\n");
}
}

2011/2012
Les boucles while et do .. while
while (condition) do
{ {
instructions instructions

} } while (condition);

 la condition (dite condition de contrôle de la boucle) est évaluée à chaque

itération. Les instructions (corps de la boucle) sont exécutés tant que la
condition est vraie, on sort de la boucle dès que la condition devient fausse

 dans la boucle while le test de continuation s'effectue avant d'entamer le corps

de boucle qui, de ce fait, peut ne jamais s'exécuter

 par contre, dans la boucle do-while ce test est effectué après le corps de
boucle, lequel sera alors exécuté au moins une fois

2011/2012
Boucle while : exemple
Un programme qui détermine le premier nombre entier N
tel que la somme de 1 à N dépasse strictement 100

main( )
{ int i, som;
i =0; som= 0;
while (som <=100)
{ i++;
som+=i;
}
printf (" La valeur cherchée est N= %d\n ", i);
}

2011/2012
Boucle do .. while : exemple
Contrôle de saisie d'une note saisie au clavier jusqu’à ce
que la valeur entrée soit valable

main()
{ int N;
do {
printf (" Entrez une note comprise entre 0 et 20 \n");
scanf("%d",&N);
} while (N < 0 || N > 20);
}

2011/2012
La boucle for
for (expr1 ; expr2 ; expr3)
{
instructions
}
 L'expression expr1 est évaluée une seule fois au début de
l'exécution de la boucle. Elle effectue l’initialisation des données de
la boucle

 L'expression expr2 est évaluée et testée avant chaque passage dans

la boucle. Elle constitue le test de continuation de la boucle.

 L'expression expr3 est évaluée après chaque passage. Elle est

utilisée pour réinitialiser les données de la boucle

2011/2012
Boucle for : remarques
for (expr1 ; expr2 ; expr3) équivaut à :
{ expr1;
instructions while(expr2)
} { instructions
expr3;
}

 En pratique, expr1 et expr3 contiennent souvent plusieurs

initialisations ou réinitialisations, séparées par des virgules

2011/2012
Boucle for : exemple
Calcul de x à la puissance n où x est un réel non nul et n
un entier positif ou nul
main ( )
{ float x, puiss;
int n, i;
{ printf (" Entrez respectivement les valeurs de x et n \n");
scanf ("%f %d" , &x, &n);
for (puiss =1, i=1; i<=n; i++)
puiss*=x;
printf (" %f à la puissance %d est égal à : %f", x,n,puiss);
}
}

2011/2012
 L’instruction break
 L’instruction break peut être utilisée dans une boucle (for, while, ou do .. while).
Elle permet d’arrêter le déroulement de la boucle et le passage à la première
instruction qui la suit

 En cas de boucles imbriquées, break ne met fin qu’ à la boucle la plus interne
 {int i,j;
for(i=0;i<4;i++)
for (j=0;j<4;j++)
{ if(j==1) break;
printf("i=%d,j=%d\n ",i,j);
}
} résultat: i=0,j=0
i=1,j=0
i=2,j=0
i=3,j=0

2011/2012
 L’instruction continue
 L’instruction continue peut être utilisée dans une boucle (for, while, ou
do .. while). Elle permet l’abandon de l’itération courante et le passage à
l’itération suivante

 {int i;
for(i=1;i<5;i++)
{printf("début itération %d\n " ,i);
if(i<3) continue;
printf(" fin itération %d\n " ,i);
}
} résultat: début itération 1
début itération 2
début itération 3
fin itération 3
début itération 4
fin itération 4

2011/2012
Chapitre 5

Les tableaux
Tableaux
 Un tableau est une variable structurée composée d’un nombre de
variables simples de même type désignées par un seul identificateur

 Ces variables simples sont appelées éléments ou composantes du

tableau, elles sont stockées en mémoire à des emplacements
contigus (l’un après l’autre)

 Le type des éléments du tableau peut être :

• simple : char, int, float, double, …
• pointeur ou structure (chapitres suivants)

 On peut définir des tableaux :

• à une dimension (tableau unidimensionnel ou vecteur)
• à plusieurs dimensions (tableau multidimensionnel )
 Déclaration des tableaux
 La déclaration d'un tableau à une dimension s'effectue en précisant le
type de ses éléments et sa dimension (le nombre de ses éléments) :

• Syntaxe en C : Type identificateur[dimension];

• Exemple : float notes[30];

 La déclaration d’un tableau permet de lui réserver un espace mémoire

dont la taille (en octets) est égal à : dimension * taille du type

 ainsi pour :
• short A[100]; // on réserve 200 octets (100* 2octets)
• char mot[10]; // on réserve 10 octets (10* 1octet)
 Initialisation à la déclaration
 On peut initialiser les éléments d’un tableau lors de la déclaration, en
indiquant la liste des valeurs respectives entre accolades. Ex:
• int A[5] = {1, 2, 3, 4, 5};
• float B[4] = {-1.5, 3.3, 7e-2, -2.5E3};
 Si la liste ne contient pas assez de valeurs pour toutes les
composantes, les composantes restantes sont initialisées par zéro
• Ex: short T[10] = {1, 2, 3, 4, 5};
 la liste ne doit pas contenir plus de valeurs que la dimension du
tableau. Ex: short T[3] = {1, 2, 3, 4, 5}; Erreur

 Il est possible de ne pas indiquer la dimension explicitement lors de

l'initialisation. Dans ce cas elle est égale au nombre de valeurs de la
liste. Ex: short T[ ] = {1, 2, 3, 4, 5}; tableau de 5 éléments
 Accès aux composantes d’un tableau
 L'accès à un élément du tableau se fait au moyen de l'indice. Par
exemple, T[i] donne la valeur de l'élément i du tableau T

 En langage C l’indice du premier élément du tableau est 0. L’indice

du dernier élément est égal à la dimension-1

Ex: int T[ 5] = {9, 8, 7, 6, 5};

T[0]=9, T[1]=8, T[2]=7, T[3]=6, T[4]=5
Remarques:
 on ne peut pas saisir, afficher ou traiter un tableau en entier, ainsi on ne peut
pas écrire printf(" %d",T) ou scanf(" %d",&T)

 On traite les tableaux élément par élément de façon répétitive en utilisant

des boucles
Tableaux : saisie et affichage
 Saisie des éléments d’un tableau T d’entiers de taille n :

for(i=0;i<n;i++)
{ printf ("Entrez l'élément %d \n ",i + 1);
scanf(" %d" , &T[i]);
}

 Affichage des éléments d’un tableau T de taille n :

for(i=0;i<n;i++)
printf (" %d \t",T[i]);
Tableaux : exemple
 Calcul du nombre d'étudiants ayant une note supérieure à 10 :

main ( )
{ float notes[30];
int nbre,i;
for(i=0;i<30;i++)
{ printf ("Entrez notes[%d] \n ",i);
scanf(" %f" , &notes[i]);
}
nbre=0;
for (i=0; i<30; i++)
if (notes[i]>10) nbre+=1;
printf (" le nombre de notes > à 10 est égal à : %d", nbre);

}
Tableaux à plusieurs dimensions
On peut définir un tableau à n dimensions de la façon suivante:

 Type Nom_du_Tableau[D1][D2]…[Dn]; où Di est le nombre

d’éléments dans la dimension i

 Exemple : pour stocker les notes de 20 étudiants en 5 modules

dans deux examens, on peut déclarer un tableau :

float notes[20][5][2];

(notes[i][j][k] est la note de l’examen k dans le module j pour

l’étudiant i)
 Tableaux à deux dimensions
(Matrices)
 Syntaxe : Type nom_du_Tableau[nombre ligne][nombre colonne];
 Ex: short A[2][3]; On peut représenter le tableau A de la manière
suivante :
A[0][0] A[0][1] A[0][2]
A[1][0] A[1][1] A[1][2]

 Un tableau à deux dimensions A[n][m] est à interpréter comme un

tableau unidimensionnel de dimension n dont chaque composante
A[i] est un tableau unidimensionnel de dimension m.

 Un tableau à deux dimensions A[n][m] contient n* m composantes.

Ainsi lors de la déclaration, on lui réserve un espace mémoire dont la
taille (en octets) est égal à : n*m* taille du type
Initialisation à la déclaration
d’une Matrice
 L’initialisation lors de la déclaration se fait en indiquant la liste des
valeurs respectives entre accolades ligne par ligne

 Exemple :
• float A[3][4] = {{-1.5, 2.1, 3.4, 0}, {8e-3, 7e-5,1, 2.7 }, {3.1, 0, 2.5E4, -1.3E2}};

A[0][0]=-1.5 , A[0][1]=2.1, A[0][2]=3.4, A[0][3]=0

A[1][0]=8e-3 , A[1][1]=7e-5, A[1][2]=1, A[1][3]=2.7
A[2][0]=3.1 , A[2][1]=0, A[2][2]=2.5E4, A[2][3]=-1.3E2

 On peut ne pas indiquer toutes les valeurs: Les composantes

manquantes seront initialisées par zéro

 Comme pour les tableaux unidimensionnels, Il est défendu d'indiquer

trop de valeurs pour une matrice
Matrices : saisie et affichage
 Saisie des éléments d’une matrice d’entiers A[n][m] :

for(i=0;i<n;i++)
for(j=0;j<m;j++)
{ printf ("Entrez la valeur de A[%d][%d] \n ",i,j);
scanf(" %d" , &A[i][j]);
}

 Affichage des éléments d’une matrice d’entiers A[n][m] :

for(i=0;i<n;i++)
{ for(j=0;j<m;j++)
printf (" %d \t",A[i][j]);
printf("\n");
}
Représentation d’un tableau en
mémoire
 La déclaration d’un tableau provoque la réservation automatique par le
compilateur d’une zone contiguë de la mémoire.

 La mémoire est une succession de cases mémoires. Chaque case est

une suite de 8 bits (1 octet), identifiée par un numéro appelé adresse.
(on peut voir la mémoire comme une armoire constituée de tiroirs numérotés. Un numéro
de tiroir correspond à une adresse)

 Les adresses sont souvent exprimées en hexadécimal pour une écriture

plus compacte et proche de la représentation binaire de l’adresse. Le
nombre de bits d’adressage dépend des machines.

 En C, l’opérateur & désigne adresse de. Ainsi, printf(" adresse de a=

%x ", &a) affiche l’adresse de la variable a en hexadécimal
Représentation d’un tableau à une
dimension en mémoire
 En C, le nom d'un tableau est le représentant de
l'adresse du premier élément du tableau (pour un 1E05
tableau T: T=&T[0] ) T1E06 100

 Les composantes du tableau étant stockées en 1E08 200

mémoire à des emplacements contigus, les
adresses des autres composantes sont calculées
(automatiquement) relativement à cette adresse : 1E0A 300
&T[i]= &T[0]+sizeof(type)*i
1E0C 400
 Exemple : short T[5] = {100, 200, 300, 400, 500};
1E0E 500
et supposons que T=&T[0] =1E06
1E0F
 On peut afficher et vérifier les adresses du tableau:
for(i=0;i<5;i++)
printf("adresse de T[%d]= %x\n",i,&T[i]);
 Représentation d’un tableau à
deux dimensions en mémoire
 Les éléments d’un tableau sont stockées en mémoire à
des emplacements contigus ligne après ligne A[0]0118 A[0][0]
A[0][1]
 Comme pour les tableaux unidimensionnels, le nom d'un A[0][2]
tableau A à deux dimensions est le représentant de A[0][3]
l'adresse du premier élément : A=&A[0][0]
A[1]011C A[1][0]
A[1][1]
 Rappelons qu’une matrice A[n][m] est à interpréter comme A[1][2]
un tableau de dimension n dont chaque composante A[i]
est un tableau de dimension m. A[1][3]
A[2] 0120 A[2][0]
A[i] et &A[i][0] représentent l’adresse du 1er élément de la
A[2][1]
ligne i (pour i de 0 à n-1)
A[2][2]
A[2][3]
 Exemple : char A[3][4]; A=&A[0][0] =0118
 Structure
 C'est une collection des champs pour des
données qui peuvent être de types
différents.
 Syntaxe :
struct nom {
déclarations des champs;
};
 Dans ce cas, struct nom devient un nouveau type
◦ Le nom est facultatif, quoique sans nom, nous
ne pouvons pas déclarer de variable de ce type
 Structure
 Autre syntaxe possible :
typedef struct {
déclarations des champs;
}nom;
 Dans ce cas, nom devient un nouveau type
 Déclarations des champs
◦ Chaque champ est déclaré avec son type et le
nom du champ
 Structure
 Accès à un champ d’une structure
◦ Si personne est une variable de type
structure
 personne.taille accède au champ taille de cette
variable
◦ Si pers est un pointeur sur une variable de
type structure
 pers->taille accède au champ taille de la variable
pointée par pers
 Tableau de structures
 Justification
◦ Supposons que nous avons beaucoup
d’informations se rapportant à un même objet
et que nous devons traiter plusieurs de ces
objets.
 int marque[MAX];
 int modele[MAX];
 int cassette[MAX];
 int cd[MAX];
 int mp3[MAX];
 float prix[MAX];
◦ En utilisant un tableau pour chaque information, on
obtient 6 tableaux
 Tableau de structures
◦ L’utilisation de tableaux à 2 dimensions peut
diminuer un peu le nombre de tableaux à gérer
 int marque[MAX];
 int modele[MAX];
 int options[MAX][3];
 float prix[MAX];
◦ On obtient ainsi 4 tableaux
 Il serait intéressant de pouvoir contenir toute
l’information dans un seul tableau
 Tableau de structures
 Déclaration de la structure
◦ typedef struct{
int marque;
int modele;
int cassette;
int cd;
int mp3;
float prix;
} radio;
 Tableau de structures
 Déclaration d’un tableau de structures
radio tabRadio[MAX];

◦ Cette déclaration réserve de l’espace pour MAX

variables de type radio.
 Avantages
◦ Un seul tableau à passer en paramètre à des
fonctions
◦ Ce prête bien à l’utilisation de fichiers binaires.
Chapitre 7

Les fonctions

2011/2012
 La programmation modulaire
 Certains problèmes conduisent à des programmes longs, difficiles à écrire età
comprendre. On les découpe en des parties appelées sous-programmes ou
modules
 Les modules sont des groupes d'instructions qui fournissent une solution àdes
parties bien définies d'un problème plus complexe. Ils ont plusieurs intérêts :

• permettent de "factoriser" les programmes, càd de mettre en commun

les parties qui se répètent
• permettent une structuration et une meilleure lisibilité des programmes
• facilitent la maintenance du code (il suffit de modifier une seule fois)
• peuvent éventuellement être réutilisées dans d'autres programmes

 La structuration de programmes en sous-programmes se fait en C à l'aidedes

fonctions

2011/2012
Fonctions
 On définit une fonction en dehors de la fonction principale main ( ) par :
type nom_fonction (type1 arg1,…, typeN argN)
{
instructions constituant le corps de la fonction
return (expression)
}
 Dans la première ligne (appelée en-tête de la fonction) :
• type est le type du résultat retourné. Si la fonction n’a pas de résultat à
retourner, elle est de type void.
• le choix d'un nom de fonction doit respecter les mêmes règles que celles
adoptées pour les noms de variables.
• entre parenthèses, on spécifie les arguments de la fonction et leurs
types. Si une fonction n'a pas de paramètres, on peut déclarer la liste
des paramètres comme (void) ou simplement comme ()
 Pour fournir un résultat en quittant une fonction, on dispose de la commande
return.
3

2011/2012
 Fonctions : exemples
 Une fonction qui calcule la somme  Une fonction qui renvoie un
de deux réels x et y : entier saisi au clavier
 double Som(double x, double y )  int RenvoieEntier( void )
 {  {
 return (x+y);  int n;
 }
printf(" Entrez n
\n"); scanf (" %d ",
 Une fonction qui affiche la somme de &n); return n;
deux réels x et y : }

 Une fonction qui affiche les
 void AfficheSom(double x, double
éléments d’un tableau d’entiers
y)
 void AfficheTab(int T[ ], int n)
 {
 { int i;
 printf (" %lf", x+y );
 for(i=0;i<n;i++)
 }
printf (" %d \t", T[i]);
4
 }
2011/2012
Appel d’une fonction
 L‘appel d'une fonction se fait par simple écriture de son nom avec la liste
des paramètres : nom_fonction (para1,…, paraN)
 Lors de l'appel d'une fonction, les paramètres sont appelés paramètres
effectifs : ils contiennent les valeurs pour effectuer le traitement. Lors de la
définition, les paramètres sont appelés paramètres formels.
 L'ordre et les types des paramètres effectifs doivent correspondre à ceux
des paramètres formels

 Exemple d’appels:
main( )
{ double z;
int A[5] = {1, 2, 3, 4, 5};
z=Som(2.5, 7.3);
AfficheTab(A,5);
}

2011/2012
Déclaration des fonctions
 Il est nécessaire pour le compilateur de connaître la définition d'une
fonction au moment où elle est appelée. Si une fonction est définie
après son premier appel (en particulier si elle définie après main ),
elle doit être déclarée auparavant.

 La déclaration d'une fonction se fait par son prototype qui indique

les types de ses paramètres et celui de la fonction :
type nom_fonction (type1,…, typeN)

 Il est interdit en C de définir des fonctions à l'intérieur d'autres

fonctions. En particulier, on doit définir les fonctions soit avant, soit
après la fonction principale main.

2011/2012
Déclaration des fonctions :exemple
#include<stdio.h>
float ValeurAbsolue(float); //prototype de la fonction ValeurAbsolue
main( )
{ float x=-5.7,y;
y= ValeurAbsolue(x);
printf("La valeur absolue de %f est : %f \n " , x,y);
}
//Définition de la fonction ValeurAbsolue
float ValeurAbsolue(float a)
{
if (a<0) a=-a;
return a;
}

2011/2012
Variables locales et globales
 On peut manipuler 2 types de variables dans un programme C : des
variables locales et des variables globales. Elles se distinguent
par ce qu'on appelle leur portée (leur "espace de visibilité", leur
"durée de vie")

 Une variable définie à l'intérieur d’une fonction est une variable

locale, elle n’est connue qu'à l'intérieur de cette fonction. Elle est
créée à l'appel de la fonction et détruite à la fin de son exécution

 Une variable définie à l’extérieur des fonctions est une variable

globale. Elle est définie durant toute l’application et peut être utilisée
et modifiée par les différentes fonctions du programme.

2011/2012
Variables locales et globales :
remarques
 Les variables déclarées au début de la fonction principale main ne
sont pas des variables globales, mais elles sont locales à main

 Une variable locale cache la variable globale qui a le même nom

• Il faut utiliser autant que possible des variables locales. Ceci permet
d'économiser la mémoire et d'assurer l'indépendance de la fonction

• En C, une variable déclarée dans un bloc d'instructions est

uniquement visible à l'intérieur de ce bloc. C’est une variable locale à
ce bloc, elle cache toutes les variables du même nom des blocs qui
l'entourent

2011/2012
 Variables locales et globales :
exemple
#include<stdio.h>
int x = 7;
int f(int);
int g(int);
main( )
{ printf("x = %d\t", x);
{ int x = 6; printf("x = %d\t", x); }
printf("f(%d) = %d\t", x, f(x));
printf("g(%d) = %d\t", x, g(x));
}
int f(int a) { int x = 9; return (a + x); }
int g(int a) { return (a * x); }
Qu’affiche ce programme?
x=7 x=6 f(7)=16 g(7) = 49

10

2011/2012
 Variables locales et globales :
exemple
#include<stdio.h>
void f(void);
int i;
main( )
{ int k = 5;
i=3; f(); f();
printf("i = %d et k=%d \n", i,k); }
void f(void) { int k = 1;
printf("i = %d et k=%d \n", i,k);
i++;k++;}
Qu’affiche ce programme?
i=3 et k=1
i=4 et k=1
i=5 et k=5

11

2011/2012
 La fonction main peut également posséder
des paramètres formels.
 un programme C peut recevoir une liste
d’arguments au lancement de son
exécution.
 La ligne de commande qui sert à lancer le
programme est, dans ce cas, composée du
nom du fichier exécutable suivi par des
paramétres.
2011/2012
la fonction main possède deux paramètres
formels, appelés par convention:
argc (argument count)
argv (argument vector).

2011/2012
 argc est une variable de type int dont la
valeur est égale au nombre de mots
composant la ligne de commande (y
compris le nom de l’exécutable). Elle est
donc égale au nombre de paramètres
effectifs de la fonction + 1.

2011/2012
 argv est un tableau de chaînes de
caractères correspondant chacune à un
mot de la ligne de commande. Le premier
élément argv[0] contient donc le nom de
la commande (du fichier exécutable), le
second argv[1] contient le premier
paramètre. . . .

 int main ( int argc, char *argv[]);

2011/2012
 #include <stdio.h> // exemple1.c
 #include <stdlib.h> //gcc -o test exemple1.c

 int main(int argc, char *argv[])

 { int a, b;
 if (argc != 3)
 {
 printf("\nErreur : nombre invalide d’arguments");
 printf("\nUsage: %s int int\n",argv[0]);
 return(EXIT_FAILURE);
 }
 a = atoi(argv[1]);
 b = atoi(argv[2]);
 printf("\nLe produit de %d par %d vaut : %d\n", a, b, a * b);
 return(EXIT_SUCCESS); }
2011/2012
 On lance donc l’exécutable avec deux
paramètres entiers, par exemple,
test 2 8
 Ici, argv sera un tableau de 3 chaînes de
caractères argv[0], argv[1] et argv[2]
argv[0]=" test", argv[1]= "2" et argv[2] ="8".

 la fonction de la librairie standard atoi(),

déclarée dans stdlib.h, prend en argument une
chaine de caractères et retourne l’entier dont
elle est l’écriture décimale.

2011/2012
Paramètres d'une fonction
 Les paramètres servent à échanger des informations entre la
fonction appelante et la fonction appelée. Ils peuvent recevoir des
données et stocker des résultats

 Il existe deux modes de transmission de paramètres dans les

langages de programmation :
• La transmission par valeur : les valeurs des paramètres effectifs sont
affectées aux paramètres formels correspondants au moment del'appel
de la fonction ou procédure. Dans ce mode le paramètre effectif ne
subit aucune modification

• La transmission par adresse (ou par référence) : les adresses des

paramètres effectifs sont transmises à la fonction appelante. Dans ce
mode, le paramètre effectif subit les mêmes modifications que le
paramètre formel

18

2011/2012
Transmission des
paramètres en C
 La transmission des paramètres en C se fait toujours par valeur
 Pour effectuer une transmission par adresse en C, on déclare le
paramètre formel de type pointeur et lors d'un appel de la fonction, on
envoie l'adresse et non la valeur du paramètre effectif
 Exemple : void Increment (int x, int *y)

{ x=x+1;
*y =*y+1; }
main( )
{ int n = 3, m=3;
Increment (n, &m);
printf(“n = %d et m=%d \n", n,m); }
Résultat :
n=3 et m= 4

19

2011/2012
Exemples
Une fonction qui échange le contenu de deux variables :
void Echange (float *x, float *y)
{ float z;
z = *x;
*x = *y;
*y = z;
}
main()
{ float a=2,b=5;
Echange(&a,&b);
printf("a=%f,b=%f\n ",a,b);
}

20

2011/2012
Récursivité
 Une fonction qui fait appel à elle-même est une fonction récursive

 Toute fonction récursive doit posséder un cas limite (cas trivial) qui
arrête la récursivité

 Exemple : Calcul du factorielle

int fact (int n )
{ if (n==0) /*cas trivial*/
return (1);
else
return (n* fact(n-1) );
}
Remarque : l’ordre de calcul est l’ordre inverse de l’appel de la fonction
21

2011/2012
Fonctions récursives :
exercice
 Ecrivez une fonction récursive (puis itérative) qui calcule le terme n
de la suite de Fibonacci définie par : U(0)=U(1)=1
U(n)=U(n-1)+U(n-2)

int Fib (int n)

{
if (n==0 || n==1)
return (1);
else
return ( Fib(n-1)+Fib(n-2));

22

2011/2012
Fonctions récursives :
exercice (suite)
 Une fonction itérative pour le calcul de la suite de Fibonacci :
int Fib (int n)
{ int i, AvantDernier, Dernier, Nouveau;
if (n==0 || n==1) return (1);
AvantDernier=1; Dernier =1;
for (i=2; i<=n; i++)
{ Nouveau= Dernier+ AvantDernier;
AvantDernier = Dernier;
Dernier = Nouveau;
}
return (Nouveau);
}
Remarque: la solution récursive est plus facile à écrire

23

2011/2012
Chapitre 8

Les Chaînes de caractères

2011/2012
 Chaînes de caractères
 Il n'existe pas de type spécial chaîne ou string en C. Une chaîne de
caractères est traitée comme un tableau de caractères

 Une chaîne de caractères en C est caractérisée par le fait que le

dernier élément vaut le caractère ‘\0’, ceci permet de détecter la fin de
la chaîne

 Il existe plusieurs fonctions prédéfinies pour le traitement des chaînes

de caractères (ou tableaux de caractères )

25

2011/2012
 Déclaration
 Syntaxe : char <NomVariable> [<Longueur>]; //tableau de caractères

Exemple : char NOM [15];

 Pour une chaîne de N caractères, on a besoin de N+1 octets en

mémoire (le dernier octet est réservé pour le caractère ‘\0’)

 Le nom d’une chaîne de caractères est le représentant de l’adresse

du 1er caractère de la chaîne

 On peut aussi manipuler les chaînes de caractères en utilisant des

pointeurs (de la même façon qu'un pointeur sur int peut contenir l'adresse
d'un élément d'un tableau d’entiers, un pointeur sur char peut pointer sur les
éléments d'un tableau de caractères)

26

2011/2012
 Initialisation
 On peut initialiser une chaîne de caractères à la définition :

• comme un tableau, par exemple : char ch[ ] = {‘e’,’c’,’o’,’l’,’e’,’\0’}

• par une chaîne constante, par exemple : char ch[ ] = "école“
• en attribuant l'adresse d'une chaîne de caractères constante à un pointeur
sur char, par exemple : char *ch = "école“

 On peut préciser le nombre d'octets à réserver à condition que celui-ci

soit supérieur ou égal à la longueur de la chaîne d'initialisation

• char ch[ 6] = "école“ est valide

• char ch[ 4] = "école“ ou char ch[ 5] = "école“ provoque uneerreur

27

2011/2012
 Traitement des chaînes de
caractères
 Le langage C dispose d’un ensemble de bibliothèques qui contiennent
des fonctions spéciales pour le traitement de chaînes de caractères

 Les principales bibliothèques sont :

• La bibliothèque <stdio.h>

• La bibliothèque <string.h>

• La bibliothèque <stdlib.h>

 Nous verrons les fonctions les plus utilisées de ces bibliothèques

28

2011/2012
 Fonctions de la bibliothèque
<stdio.h>

 printf( ) : permet d’afficher une chaîne de caractères en utilisant le

spécificateur de format %s.

Exemple : char ch[ ]= " Bonsoir " ;

printf(" %s ", ch);

 puts( <chaine>) : affiche la chaîne de caractères désignée par

<Chaîne> et provoque un retour à la ligne.

Exemple : char *ch= " Bonsoir " ;

puts(ch); /*équivalente à printf("%s\n ", ch);*/

29

2011/2012
 Fonctions de la bibliothèque
<stdio.h>
 scanf( ) : permet de saisir une chaîne de caractères en utilisant le
spécificateur de format %s.

Exemple : char Nom[15];

printf("entrez votre nom");
scanf(" %s ", Nom);
Remarque : le nom d'une chaîne de caractères est le représentant de
l'adresse du premier caractère de la chaîne, il ne doit pas être précédé de &

 gets( <chaine>) : lit la chaîne de caractères désignée par <Chaîne>

Exemple : char phrase[100];

printf("entrez une phrase");
gets(phrase);

30

2011/2012
 Fonctions de la bibliothèque
<string.h>
 strlen(ch): fournit la longueur de la chaîne sans compter le '\0' final
Exemple : char s[ ]= " Test";
printf(“%d”,strlen(s)); //affiche 4

 strcat(ch1, ch2) : ajoute ch2 à la fin de ch1. Le caractère ‘\0’ de ch1

est écrasé par le 1er caractère de ch2

Exemple : char ch1[20]=" Bonne ", *ch2=" chance ";

strcat(ch1, ch2) ;
printf(" %s", ch1); // affiche Bonne chance

31

2011/2012
 Fonctions de la bibliothèque
<string.h>
 strcmp(ch1, ch2): compare ch1 et ch2 lexicographiquement et
retourne une valeur : - nul si ch1 et ch2 sont identiques
- négative si ch1 précède ch2
- positive si ch1 suit ch2

 strcpy(ch1, ch2) : copie ch2 dans ch1 y compris le caractère ‘\0’

Exemple : char ch[10];

strcpy(ch, " Bonjour ");
puts(ch); // affiche Bonjour
 strchr(char *s, char c) : recherche la 1ère occurrence du caractère c
dans la chaîne s et retourne un pointeur sur cette 1ère occurrence si
c’est un caractère de s, sinon le pointeur NULL

32

2011/2012
 Fonctions de la bibliothèque
<stdlib.h>
<stdlib> contient des fonctions pour la conversion de nombres en
chaînes de caractères et vice-versa.

 atoi(ch): retourne la valeur numérique représentée par ch comme int

 atof(ch): retourne la valeur numérique représentée par ch comme float
(si aucun caractère n’est valide, ces fonctions retournent 0)
Exemple : int x, float y;
char *s= " 123 ", ch[]= " 4.56 ";
x=atoi(s); y=atof(ch); // x=123 et y=4.56

 itoa(int n, char * ch, int b) : convertit l’entier n en une chaîne de

caractères qui sera attribué à ch. La conversion se fait en base b
Exemple : char ch[30]; int p=18;
itoa(p, ch, 2); // ch= " 10010 ";

33

2011/2012