Module : Informatique 2

Cours
Programmation en langage C

Pr. Samira MABTOUL

mabtoul.samira@uit.ac.ma
Objectifs du cours

1. Prise en main des éléments de base du Langage C

2. Comprendre la syntaxe du langage C

3. Apprendre à programmer en langage C

2
Contenu du cours
 Introduction au langage C

 Types de base, Opérateurs et Expressions

 Quelques fonctions particulières (les entrées-sorties)

 Les structures de contrôle

 Les tableaux, les pointeurs

 Les fonctions

 Les chaînes de caractères

 Types dérivés (structure, énumération, …)

 Les fichiers,...

3
 Chapitre 1
INTRODUCTION AU LANGAGE C

4
Préliminaire

 Avant la phase d’écriture d’un programme et de son implémentation, il faut d’abord

bien définir le problème (et les données associées) et c’est l’algorithmique qui
permet de le résoudre
 Algorithme : séquence d’opérations visant à la résolution d’un problème en un
temps fini

 Une fois l’algorithme et les structures de données définis, on les code en un

langage informatique et on obtient un programme

• Programme : suite d’instructions permettant de réaliser une ou plusieurs tâches,

de résoudre un problème, de manipuler des données

 La programmation nécessite d’avoir un bon sens de la logique et d’être méthodique

 Nombreux langages de plus haut niveau ont été définis :

 La programmation structurée (C, Pascal, …)
 La programmation fonctionnelle (Lisp,…)
 La programmation logique (Prolog, …)
 La programmation scientifique (Maple, Matlab,…)
 La programmation objet (C++, Java, …) 5
Historique du langage C

 1972 : Dennis Ritchie (chercheur dans les laboratoires Bell) a conçu le

langage C pour développer une version portable du système d’exploitation
UNIX

 1978 : une 1ère définition du langage est apparue avec l’ouvrage de Ritchie
et Kernighan « The C programming language »

 Années 80 : le langage C est devenu de plus en plus populaire que ce soit

dans le monde académique que celui des professionnels

 1983 : l’organisme ANSI «American National Standards Institute »

chargeait une commission de mettre au point une définition explicite et
indépendante de la machine pour le langage C

 1989 : définition de la norme ANSI-C (C89)

Le C est l’un des langages de programmation les plus célèbres et les plus
utilisés au monde

s 6
Caractéristiques du langage C

 Universel : C n'est pas orienté vers un domaine d'application spéciale

(applications scientifiques, de gestion, …)

 Proche de la machine : il offre des opérateurs qui sont très proches de

ceux du langage machine (ex. la gestion de la mémoire : manipulations de
bits, d’adresses, …)

 Rapide : car très proche du langage machine

 Indépendant de la machine : il peut être utilisé sur n'importe quel système

en possession d'un compilateur C

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

même programme sur tout autre système d'exploitation

 Extensible : le langage est animé par des bibliothèques de fonctions

extensibles

7
Étapes de la programmation en C
 C est un langage compilé ( par opposition aux langages interprétés)

 Un programme C est décrit par un fichier texte, appelé fichier source traduit en
langage machine (langage binaire). Cette opération est effectuée par le compilateur
C

 La compilation se décompose en 4 phases successives :

Préprocesseur : transformation
purement textuelle (inclusion
d’autres fichiers sources…)
Compilation : traduit le fichier pour
générer un code en assembleur
Assemblage : transforme le code
assembleur en un fichier binaire (
fichier objet)
Edition de liens : liaison des
différents fichiers objets et
production de l’exécutable

8
Compilateur 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/

 Nous allons utiliser 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 site

www.bloodshed.net

9
Exemple d’une fenêtre Dev-C++

10
Composantes d’un programme en C

 Les instructions du langage C sont obligatoirement encapsulées dans des

fonctions et il existe une fonction privilégiée appelée main() qui est le point
de départ de tout programme

Début du programme

#include <stdio.h> Inclusion des bibliothèques

main() Point d'entrée du programme

{ int i=3; Déclaration des variables

printf("Bonjour %d fois!\n", i); Affichage de données

/*Ce programme affiche Bonjour 3 fois!*/ Commentaire

} Fin du programme 11
Composantes d’un programme en C

Plusieurs écritures possibles :

1. main()
{}

2. void main()
{}

3. int main()
{}
4. int main (int argc, char * argv[])
{}

12
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 "Bonjour %d fois!\n" permet d’afficher :

Bonjour 3 fois! 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 */

13
 Chapitre 2

VARIABLES, TYPES DE BASE, OPÉRATEURS ET

EXPRESSIONS

14
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, …)

15
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é :

{a-z, A-Z, 0-9, _ }

• Le 1er caractère doit être un CARACTERE ou le _ (underscore)

• La longueur des identificateurs n'est pas limitée, mais C distingue seulement les
31 premiers caractères

• 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 est un langage qui respecte la casse, il distingue les majuscules et les

minuscules. NOMBRE et nombre sont des identificateurs différents

 Donner des noms clairs à vos variables

16
Types de base (1/2)

 Un type définit l'ensemble des valeurs que peut prendre une variable, le
nombre d'octets à réserver en mémoire et les opérateurs que l'on peut
appliquer dessus

 En C, il n'y a que deux types de base : les entiers et les réels

 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 (structures)

 Avec les nombres décimaux, l’ordinateur ne connaît pas la virgule, il utilise le

point

 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 zéro équivaut à faux)
17
Types de base (2/2)

Type Description Octets

Entiers char caractères 1
int entiers 2 ou 4
short [int] entiers courts 2
long [int] entiers longs 4
Réels float nombres décimaux 4
double nombres décimaux de précision supérieure 8
long double nombres décimaux encore plus précis 10 ou 12

 Remarques :
 Un caractère char est un nombre entier (il s'identifie à son code ASCII). Par
conséquent, une variable de type char peut contenir une valeur entre -128 et
127 et elle peut subir les mêmes opérations que les variables du type short, int
ou long
 Si on ajoute le préfixe unsigned à un entier, alors on manipule des entiers non
signés [de 0 à 2n-1 avec n représente le nombre de bits occupés dans la
mémoire]. Exemple : unsigned char, unsigned short,, … 18
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 lors de la déclaration)

 Déclaration d'une variable :

<Type>< nom_de_la_variable> [= valeur];

<Type> <NomVar1>[=valeur],<NomVar2>[= valeur],...,<NomVarN>[= valeur];

• Type : Conditionne le format de la variable en mémoire

• Nom : Unique pour chaque variable (identificateur)

• Valeur : Peut évoluer pendant l'exécution ou initialisation grâce à l'opérateur

d'affectation (=)

 Exemple
 int i, j, nb; char c = 'a';
 float pi = 3.14; double r = 6.2879821365;

19
Définition d’une constante
 En utilisant l'attribut const, la valeur d'une variable ne change pas au cours
de l’exécution du programme (avec une réservation d’espace mémoire) :

const type nom_constante = expression ;

Exemples

const int MAX = 767 ;

const char NEWLINE = '\n' ;

 La directive #define permet de donner un nom à une constante. Dans ce

cas le préprocesseur effectue le remplacement correspondant avant la
compilation (Pas de réservation d’espace mémoire ) :

#define nom_constante valeur

Exemples

#define TVA 20 int a = TVA; /* a prend la valeur 20*/

#define PI 3.14159 #define TRUE 1 #define FALSE 0 20

Définition d’une constante
Constantes entières

 Par défaut, une constante numérique entière est de type int et, si sa valeur
est trop grande pour le type int, elle prend celle du type « plus grand »
suffisant.

 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

 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 (0-7). 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
21
Définition d’une constante
Constantes réelles

 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

 On distingue 2 notations :

• Notation décimale : c’est l’écriture usuelle. Ex : 123.4, .27, 5.

• Notation exponentielle : Ex : 1234e-1 ou 1234E-1

22
Opérateurs, Expressions & Instructions

 Les opérateurs sont des symboles qui permettent de manipuler des

variables, c'est-à-dire effectuer des opérations. 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 trois opérandes

 Une expression est un calcul qui donne une valeur comme résultat et ayant
un type

 Une expression peut comporter des constantes, des variables et des

appels de fonctions combinés entre eux par des opérateurs et former ainsi
une expression complexe. Exemple : 1, b, a*2, a+3*b-c

 Toute expression suivie d'un point virgule ; devient une instruction

23
Les opérateurs (1/10)
 Opérateur d’affectation simple =

Syntaxe : <variable> = <expression> ;

Exemple : const int LONG = 141 ; /* affectation de valeurs constantes */

• On peut enchaîner des affectations. L'évaluation commence de la droite vers la

gauche. Exemples :

 a =b = c = 5  c = 5, b = c et ensuite a = b  a=5

 b=(a = 5 + 3)+1  a = 8 et b = 9

 Opérateurs d'affectation étendue += -= *= /= %=

Exemple : a = a + b s'écrit a += b

24
Les opérateurs (2/10)
 Opérateurs Arithmétiques

addition(+), soustraction(-), multiplication(*), division (/), reste de la division(%)

 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 au moins l’un des opérandes est un
réel (5.0 / 2  2.5)

25
Les opérateurs (3/10)
 Conversions implicites
• Les types short et char sont systématiquement convertis en int
indépendamment 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

• Exemple : n * p + x avec n : int, p : long et x: float

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

26
Les opérateurs (4/10)
 Opérateurs Relationnels <, <= , > , >= , != (différent ) , == (égalité)
 Le résultat de la comparaison est un entier valant
 0 si le résultat de la comparaison est faux
 1 si le résultat de la comparaison est vrai

 Opérateurs Logiques ! (négation), || (ou logique), && (et logique)

 && retourne vrai(1) si les deux opérandes sont vrais(valent 1) et 0 sinon
 || retourne vrai (1) si l’une des opérandes est vrai (vaut 1) et 0 sinon
 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)

27
Les opérateurs (5/10)
 Opérateurs Relationnels et logiques : Exemple

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

Donner la valeur de a dans chaque cas :

a = (6==5)
a = (2!=3)
a = (6<=3)
a =((3==3) || (6<=3))
a =((3==3) && (6<=3))
a =4*(2<7) + 2*(4>=7)

28
Les opérateurs (6/10)
 Incrémentation et décrémentation : incrémentation (++), décrémentation (--)
 Post-incrémentation <var>++; équivalente à <var>=<var>+1;
 Post-décrémentation <var>--; équivalente à <var>=<var>-1;
 Dans une expression, la valeur de la variable <var> est d'abord utilisée telle
quelle, puis incrémentée (ou décrémentée)
 Exemple :
int a, b;
a = b++; équivalent à a = b, b = b+1;

 Pré-incrémentation ++<var>; équivalente à <var>=<var>+1;

 Pré-décrémentation --<var>; équivalente à <var>=<var>-1;
 Dans une expression, la valeur de la variable <var> est d'abord incrémentée (ou
décrémentée), puis utilisée
 Exemple :
int a, b;
a = ++b; équivalent à b = b+1, a = b;
29
Les opérateurs (7/10)
 Incrémentation et décrémentation: Exemple

Avant chaque opération, i et j contiennent respectivement 3 et 15

Opération équivalent Résultat

i++;++j; i=i+1; j=j+1; i=4 et j=16
i = ++j;
i = j++;
j = --i + 5;
j = i-- + 5;
i = i++;

30
Les opérateurs (8/10)
 Opérateur séquentiel ( , ) <expr1> , <expr2>,…, <exprN>

• Exprime des calculs successifs dans une même 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 :
x = 5 , x + 6; // l’instruction a pour valeur 11

i++ , j = i + k , r = i + j; // la valeur de l’instruction est celle de r = i + j

for (i=1 , k=0 ; … ; …) { }

31
Les opérateurs (9/10)
 Opérateur conditionnel (? :) <expression> ? <expr1> : <expr2>

• <expression> est évaluée. Si sa valeur est non nulle, alors la valeur de <expr1> est
retournée. Sinon, c'est la valeur de <expr2> qui est renvoyée

• Exemple :

c=a>b?a:b

si a est la plus grande, alors affectation à c le contenu de a sinon affectation à

c le contenu de b

32
Les opérateurs (10/10)
 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 1 :
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)
• Exemple 2 :
float n = 6.2, p = 2.5 ;
(int) n / (int)p = 6/2 = 3
(int)n/p = 6 /2.5 = 2.4
n/(int)p = 6.2/2 = 3.1
n/p = 6.2/2.5 = 2.48 33
Priorité et associativité des opérateurs (1/2)
 Lors de l'évaluation des différentes parties d'une expression, les opérateurs
respectent certaines lois de priorité et d'associativité

 Les opérateurs dans une même ligne ont le même niveau de priorité. Dans ce cas
l’ordre d’évaluation est définie par le sens de la flèche
Priorité Catégorie Opérateurs Associativité
1 référence () [] -> . 
2 unaire ++ -- (Pré) !  (cast) sizeof 
3 arithmétique * / % 
4 arithmétique + - 
5 décalage << >> 
6 relationnel < <= > >= 
7 relationnel == != 
8 manip. de bits & 
9 manip. de bits ^ 
10 manip. de bits  
11 logique && 
12 logique  
13 conditionnel ?: 
14 affectation = += -= *= /= %= &= ^= |= <<= >>= 
15 séquentiel ,  34
Priorité et associativité des opérateurs (2/2)
 Exemples :

• 13 % 3 * 4 vaut 4 et non 1 (même niveau de priorité,, sens d’évaluation )

• 2 + 3 * 7 vaut 23 et non 35 (* est plus prioritaire que +)

• Remarque : en cas de doute il vaut mieux utiliser les parenthèses pour indiquer les
opérations à effectuer en priorité. Exemple : (2 + 3) * 7 vaut 35

 Exercice : soit a = 3 et b = 4, donnez le résultat de l’expression a *= b += 5

a *= ( b += 5 )

a *= ( b = b + 5 )

a *= ( b = 9 )

a *= 9

a = a * 9  a = 27

35
Exercice

Donnez la valeur de i, j, n aux endroits demandés

#include<stdio.h>
Priorité Opérateur Associativité
main()
1 () 
{
2 ! ++ -- (Pré) 
int i, j, n;
3 */% 
i=0; n=i++;
4 +- 
A:i=?n=?
5 == != 
i=10; n=++i;
6 && 
B:i=?n=?
i=20; j=5; n=i++ * ++j; 7 = += *= 

C:i=?n=?
i=15; n=i+=3;
D:i=?j=?n=?
i=3; j=5; n=i*=--j;
E:i=?j=?n=?
}
36
 Chapitre 3

QUELQUES FONCTIONS PARTICULIÈRES

Entrées-sorties

37
Les instructions de lecture et d’écriture

 Il s’agit des instructions permettant à la machine de dialoguer avec

l’utilisateur

• La lecture permet à l’utilisateur d’entrer des valeurs au clavier pour

qu’elles soient utilisées par le programme

• 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 d’entrées/sorties <stdio.h> (Standard

Input/Output Header) 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 sur la sortie standard (l’écran, par défaut)

• scanf() lecture formatée du flux standard d’entrée (le clavier, par défaut)

38
Ecriture formatée de données: printf () (1/5)

 Utilisation de la fonction printf() : pour afficher à l’écran du texte, des

valeurs de variables ou des résultats d’expressions

 Syntaxe : printf (const char * format , expr1, expr2, …) ;

• format : est une chaîne de caractères qui peut contenir du texte, des
caractères de contrôle (‘\n’ , ‘\t’ , …) et des spécificateurs de format

• expr1, expr2,… : sont les variables et les expressions dont les valeurs
sont à représenter

39
Affichage de la valeur d’une variable (2/5)
 Spécificateurs de format :

FORMAT TYPE Description

%d ou %i int entier relatif
%u Unsigned int entier naturel (unsigned)
%o Unsigned int entier exprimé en octal (unsigned)
%x ou %X Unsigned int entier exprimé en hexadécimal (unsigned)
%c char caractère
%f float ou double réel en notation décimale
%e ou %E float ou double réel en notation exponentielle
%s char* chaîne de caractères
… … …
 Remarques :
• Le nombre de spécificateurs de format doit être égale au nombre d’expressions
• Pour pouvoir traiter correctement les arguments du type long, il faut utiliser les
spécificateurs %ld, %li, %lu, %lo, %lx
• Pour pouvoir traiter correctement les arguments du type long double, il faut
utiliser les spécificateurs %Lf et %Le 40
Ecriture formatée de données: printf () (3/5)

 Caractères de contrôle (Séquences d’échappement) :

Caractère de contrôle Signification

‘\a’ Bip sonore
‘\t’ Tabulation horizontale
‘\n’ Passage à la ligne suivante
‘\r’ Retour chariot (retour au début de la même ligne)
‘\\’ Trait oblique (antislash)
‘\" ’ Guillemets
‘%%’ Affichage de %

Remarque : la caractère ‘\n’ est différent du caractère ‘\r’

41
Ecriture formatée de données: printf () (4/5)

 Exemple 1

int a = 120 ;
int b = 60 ;
printf("%i plus %i est %i\n", a, b, a + b) ;
// Affiche sur l'écran : 120 plus 60 est 180

 Exemple 2

char b = 'A' ; /* le code ASCII de A est 65 */

printf("Le caractère %c a le code %i\n", b, b) ;
// Affiche sur l'écran : Le caractère A a le code 65

42
Ecriture formatée de données: printf () (5/5)
 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. Mais, on peut préciser le nombre de chiffres
après le point décimal

• Pour agir sur l’affichage, un nombre est placé après % et précise le nombre de
caractères minimum à utiliser
 Quelques exemples : %[format][width ][. precision][modifier]<type>
printf("%.2f" , x );
printf("%3d" , n ); printf("%f" , x ); x = 1.2345 1.23
n = 20 ^20 x = 1.2345 1.234500 printf("%3.0f" , x );
n=3 ^^3 x = 12.3456789 12.345678 x = 1.2345 ^^1
n = 2358 2358 printf("%10f" , x ); //cadrage à droite printf("%#3.0f" , x );
n = -5200 -5200 x = 1.2345 ^^1.234500 x = 1.2345 ^1.
printf("%-10f" , x );//cadrage à gauche printf("%6.2f" , x );
printf("%+d" , x ); x = 1.2345 1.234500^^ x = 1.2345 ^^1.23
x = 10 +10 printf("%010f",x ); printf("%-6.2f" , x );
x = -10 -10 x = 1.2345 001.234500 x = 1.2345 1.23^^
printf("%-010f",x ); printf("%.0f" , x );
printf("%05d" , x );
x = 1.2345 1.234500^^ x = 1.5345 2
x = 10 00010
43
Lecture formatée de données: scanf () (1/2)

 Utilisation de la fonction scanf() : permet de lire des données à partir du

clavier

 Syntaxe : int scanf("const char * format", &variable1, &variable2, … )

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

• &variable1, &variable2, … : 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 &. En l'absence du symbole &, la
valeur lue sera écrite n'importe où

 Remarques :
int n = scanf("format de lecture", &variable1, &variable2, … ); avec n
représente le nombre de valeurs entrées avec succès.

44
Lecture formatée de données: scanf () (2/2)

 Exemple
#include <stdio.h>

main()
{ int n, p; //déclaration des variables

printf("donner une valeur pour n : ");

scanf("%d",&n); // lecture de la valeur de n

//affichage de la valeur de n
printf("Merci pour %d\n", n);

printf("donner une valeur pour p : ");

scanf("%d",&p); // lecture de la valeur de p

//affichage de la valeur de p
printf("Merci pour %d\n",p);
}

45
Affichage d’un caractère

 Utilisation de la fonction putchar()

 Syntaxe : putchar(variable) // variable de type int ou char

 Exemple :

char c = 'a' ;
char b = '\n' ;
putchar('x') ;
/* affiche la lettre x */
putchar('?') ;
/* affiche le symbole ? */
putchar(b) ;
/* retour à la ligne */
putchar(65) ;
/* affiche le caractère de code ASCII = 65, c-à-d. la lettre A */
putchar(c) ;
/* affiche le caractère a */

46
Lecture d’un caractère

 Utilisation de la fonction getchar()

 Syntaxe : char variable = getchar() ;

 Cette fonction peut accepter un caractère saisi au clavier, y compris un

caractère spécial, et l'afficher sur l'écran

 Exemple :
printf("donner une valeur pour le caractère c ");
char c =getchar(); // équivalent à scanf("%c",&c);

47
 Chapitre 4
STRUCTURES DE CONTROLE

48
Structures de contrôle

 Structures de choix (tests)

 Structures itératives (boucles)

 Instructions break et continue

49
Structures de choix (1/3)

 Contrôlent le déroulement de l’enchaînement des instructions à l’intérieur

d’un programme

 Ces instructions peuvent être exprimées par :

 Des instructions de branchement conditionnel : if … else
 Des instructions de branchement multiple : switch

50
Structures de choix (2/3)

 Branchement conditionnel : if ….else

 bloc d’instructions { } : peut désigner une
 Syntaxe
suite d’instructions délimitées par des
if( expression) accolades ou une seule instruction
{ instruction1;
…
} expression : expression quelconque. Après
ou évaluation, si elle est vraie, alors le 1er bloc
d’instructions est exécuté, sinon c’est le
if( expression)
2ème bloc qui est exécuté
{ instruction1;
…
}  La partie else est facultative
else
{ instruction2;
 On peut imbriquer plusieurs instructions
…
} if…else
 Exemple :
if (a == b) a=1; //si a égal à b j’affecte 1 à a
if (a == b) a=1; else a=0; //si a égal à b j’affecte 1 à a sinon j’affecte 0 à a
51
Structures de choix(3/3)
 Branchement multiple : Switch

 Permet de choisir des instructions à exécuter selon la valeur d’une

expression qui doit être de type entier

 Syntaxe  Teste si une expression prend

switch (expression) une valeur parmi une suite de
{ constantes, et effectue le
case constante_1 : instructions_1; break; branchement correspondant si
case constante_2 : instructions_2; break; c’est le cas
..............
case constante_n : instructions_n; break;  default est optionnel et peut ne
default : instructions ; pas figurer
}
int a;
 Exemple :
switch (a)
{ case 7 : a=2; break; //si a égal à 7 j’affecte 2 à a et je quitte
case 4 : a=3; break; //si a égal à 4 j’affecte 3 à a et je quitte
default : a=0; break; //sinon j’affecte 0 à a et je quitte
} 52
Structures itératives (1/3)

 Instructions itératives : while()

while( expression )
{ on vérifie la condition avant d’exécuter
instructions; la liste d’instructions
…
}

 Exemple :
int a=0;
while(a<4) //tant que a<4 j’exécute les instructions suivantes
{
a++;
printf ("La valeur de a :%d \n", a);
}

53
Structures itératives (2/3)

 Instructions itératives : do-while()

do on exécute la liste d’instructions avant
{ de vérifier la condition
instructions;
…
}
while( expression );

 Exemple :
int a=0;
do //faire les instructions suivantes
{
a++; // j’incrémente a de 1
printf ("La valeur de a :%d \n", a);
}
while(a<4); //tant que a<4

54
Structures itératives(3/3)

 Instructions itératives : for()

for( exp1 ; exp2 ; exp3 ) exp1 : effectue les initialisations nécessaires
{ avant l’entrée dans la boucle
instructions; exp2 : est le test de continuation de la boucle ; le
… test est évalué avant l’exécution du corps de la
}
boucle
exp3 : est exécutée à la fin du corps de la boucle
 Exemple :

int a; Remarques :
for( a=0 ; a<4 ; a++ )  En pratique, exp1 et exp3 contiennent
{ souvent plusieurs initialisations
printf ("La valeur de a :%d \n", a); (instructions) séparées par des virgules
}  Les expressions exp1 et exp3 peuvent
être absentes (les points virgules doivent
cependant apparaître) : for ( ; exp2 ; )

55
Instructions break et continue (1/2)

 Instruction break
 L’instruction break peut être employée à l’intérieur de n’importe quelle boucle
(for ; while ; do-while ; switch)
 Elle permet l’abandon de la boucle et le passage à la première instruction qui
suit la boucle
 En cas de boucles imbriquées, break fait sortir de la boucle la plus interne

 Exemple : qu’affiche le programme ci-dessous ?

int i, j ;
for (i = 1 ; i<=10 ; i++)
{
for (j = 1 ; j<=10 ; j++)
{
if(j == 5) break ;
printf("%d\t", i * j) ;
}
printf("\n") ;
}
56
Instructions break et continue (2/2)

 Instruction continue
 L’instruction continue peut être employée à l’intérieur d’une structure de type
boucle (for ; while ; do-while )
 Elle permet l’abandon de l’itération courante et fait passer directement à
l’itération suivante d’une boucle
 L’instruction continue concerne la boucle la plus interne

 Exemple
Valeurs Affichage
int i, j ;
i=2 et j=3 i : 2 et j : 3
……//Initialisations i : 1 et j : 2
for ( ; i>0 && j>0; i--,j--)
i=6 et j=3 i : 6 et j : 3
{
i : 4 et j : 1
if(i == 5) continue;
printf("i : %d et j : %d\n", i, j) ; i=3 et j=5 i : 3 et j : 5
if(j == 5) break ;
}
57
Exercice

 Ecrire un programme qui permute et affiche les valeurs de trois variables a,

b, c de type entier saisis par le clavier( ab, bc, ca)

 Correction
#include<stdio.h>
main()
{
int a, b, c;
int aide;
printf("entrer la valeur de a, b et c :\t");
scanf("%d %d %d", &a, &b, &c);
printf("a=%d \t b=%d\t c=%d\n", a, b, c);
aide= a , a=c , c=b , b=aide;
printf("a=%d \t b=%d\t c=%d\n", a, b, c);
}

58