Atelier de Programmation

Dr. Mariem MEFTEH

FSB, Dep. Info.

 Chapitre 1

Introduction à la programmation C

Dr. Mariem MEFTEH

Notions d’Algorithme
et de Programme
 Abstraction
Abstraction = Cacher les details quand ils ne sont pas important
Un système peut être visualisé à partir de nombreux niveaux d’abstraction différents.
Exemple:

Details
Villes

Comtés

États Bureau de recensement

Politicien américain

Pays
5

Abstraction

Hardware

Des millions de lignes de code

Exécuter uniquement des instructions
+Bibliothèques qui implémentent des fonctions
simples de bas niveau.
complexes

Application Couches de logiciels qui Instructions

complexe interprètent ou traduisent
Simples
6

Program levels: Details (1)

Programme de haut niveau

(e.g. Java) 1

compilateur
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp; Programme en langage
2

Assembleur
assembleur
lw $t0, 0($2)
lw $t1, 4($2)
sw $t1, 0($2)
Programme en langage machine 3 sw $t0, 4($2)

0000 1001 1100 0110 1010 1111 0101 1000

1010 1111 0101 1000 0000 1001 1100 0110
1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111
Tout peut être représenté sous forme de nombre,
c'est-à-dire des données ou des instructions
7

Program levels: Details (2)

Program me en langage

Implementation Interpretation
machine 3

de l’architecture Machine
0000 1001 1100 0110 1010 1111 0101 1000
1010 1111 0101 1000 0000 1001 1100 0110
1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111
4 Description de l’architecture hardware

e.g. block diagrams

Description en circuit logique 5

(Circuit Schematic Diagrams)
8

Historique
 Domaines de programmation

Applications scientifiques 1

– Un grand nombre de calculs en virgule

flottante ; utilisation de tableaux
– Fortran 2 Applications commerciales

– Produire des rapports, utiliser des

nombres décimaux et des caractères
Intelligence artificielle 3 – COBOL

– Des symboles plutôt que des chiffres

manipulés ; utilisation de listes chaînées
– LISP
 4 Programmation des systèmes

– Besoin d’efficacité en raison d’une

utilisation continue
Web 5 - C

- Balisage (par exemple, HTML)

- Scripts (par exemple, PHP)

Domaines de programmation

10
11

Historique

Le langage C a été mis au point par D.Ritchie et B.W.Kernighan au début des années 70.

Ce langage a connu plusieurs versions avant sa normalisation en 1972 par ANSI

(abréviation de American National Standards Institute) pour créer un nouveau langage : le

langage C.
12

Avantages du langage C

Le succès du C est dû aux faits que:

- C'est un langage universel: C n'est pas orienté vers un domaine d'applications spécifique (au contraire du FORTRAN:
applications scientifiques, COBOL: applications commerciales).

- C'est un langage compact: C est basé sur un noyau de fonctions et d'opérateurs limités, permettant la formulation
d'expressions simples et efficaces.

- Il est portable: en respectant le standard ANSI-C il est possible d'utiliser le même programme sur tout autre système
d'exploitation en possession d'un compilateur C

- C est un langage comportant des instructions et des structures de haut niveau (contrairement à l'assembleur par
exemple) tout en générant un code très rapide grâce à un compilateur très performant.
 Chapitre 2

Notions de base

Dr. Mariem MEFTEH

Bibliothèques de
fonctions
15

Bibliothèques de fonctions

• La pratique du C exige l'utilisation de bibliothèques de fonctions.

• Ces bibliothèques sont disponibles sous forme précompilées (.lib).

• Afin de pouvoir les utiliser, il faut inclure des fichiers en-tête (.h) dans nos programmes.

• Ces fichiers contiennent les prototypes des fonctions prédéfinies dans les bibliothèques et
créent un lien entre les fonctions précompilées et nos programmes.

• Pour inclure les fichiers en-tête:

#include <fichier.h>
16

Bibliothèques de fonctions

• Pour le compilateur, différents types de fichiers seront identifiés par leurs extensions:

.c : fichier source

.obj : fichier compilé

.exe : fichier exécutable

.h : bibliothèque en-tête
17

Composantes d'un
programme en C
18

La fonction main
• Chaque programme C possède une fonction principale qui doit être nommée main.

• La fonction main sert de point de départ pour l’exécution du programme.

• Elle contrôle généralement l'exécution du programme en dirigeant les appels à d'autres

fonctions du programme.

• Elle constitue le programme principal

• Syntaxe:

main() {

/* déclaration des variables */

/* instructions */
}
19

La fonction main
• Les fonctions du programme source effectuent une ou plusieurs tâches spécifiques.

• La fonction main peut appeler ces fonctions afin qu’elles effectuent leurs tâches respectives.

• Lorsque la fonction main appelle une autre fonction, elle passe le contrôle d’exécution à celle-ci

afin que l’exécution commence à sa première instruction.

• Une fonction retourne le contrôle à main quand une instruction return est exécutée ou que la fin

de la fonction est atteinte.

20

Les identificateurs
• Les « identificateurs » ou « symboles » sont des noms que vous fournissez pour des variables,

des types, des fonctions et des étiquettes dans votre programme.

• Les noms des fonctions et des variables en C sont composés d'une suite de lettres et de chiffres:

- le premier caractère doit être une lettre

- L'ensemble des symboles utilisables est: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, …., x, y, z, A, B, C, ….,

X, Y, Z, _}

- Le C distingue les minuscules et les majuscules

- La longueur des identificateurs n'est pas limitée, mais le C distingue des 31 premiers caractères
21

Les identificateurs

• Les noms d'identificateur doivent différer des mots clés en termes d'orthographe et de casse.

Vous ne pouvez pas utiliser des mots clés (C ou Microsoft) en tant qu’identificateurs ; ils sont

réservés à un usage spécial.

• Le compilateur C considère les majuscules et les minuscules comme des caractères distincts.

Cette fonctionnalité, appelée « respect de la casse », vous permet de créer des identificateurs

distincts qui ont la même orthographe mais différentes casses pour une ou plusieurs des lettres.

Par exemple, chacun de ces identificateurs suivants est unique :

add ADD Add aDD

22

Mots clés C
• Les mots clés sont des mots qui ont une signification spéciale pour le compilateur C.

• Un identificateur ne peut pas avoir la même orthographe et la même casse qu'un mot clé C

• Par exemple, le langage C utilise les mots clés suivants :

23

Les commentaires
• Un commentaire commence toujours par les deux symboles /* et se termine par les

deux symboles */

• Il est interdit d'utiliser des commentaires imbriqués.

Exemple:

/* ceci est un commentaire correct */

/* ceci est /* évidemment */ incorrect */

24

Les variables

• Une variable est un objet repéré par son nom, pouvant contenir des données, qui pourront être
modifiées lors de l'exécution du programme
• Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui donner un nom, mais surtout un
type de donnée à stocker afin qu'un espace mémoire conforme au type de donnée qu'elle contient
lui soit réservé.

• Une variable se déclare de la façon suivante :

type Nom_de_la_variable;
ou bien s'il y a plusieurs variables du même type :
type Nom_de_la_variable1, Nom_de_la_variable2, ...;
25

Les variables

Exemple:
int nb;
float pi = 3.14;
char c = 'a';
long i,j,k;
double r = 6.2879821365;

Remarque: Toute variable doit être déclarée avant son utilisation

26

Les variables

• En langage C, les noms de variables peuvent être aussi long que l'on désire, toutefois le
compilateur ne tiendra compte que des 32 premiers caractères.

• Le nom d’une variable doit répondre à certains critères :

• un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un « _ »

(pas par un chiffre)

• un nom de variable peut comporter des lettres, des chiffres et le caractère « _ »

(les espaces ne sont pas autorisés !)

• les noms de variables ne peuvent pas être les noms suivants (qui sont des noms réservés) :

break, case, char, do, double, else, float, for, goto, if, int,

long, return, short, switch, typedef, void, while

27

Les variables
• Les noms de variables sont sensibles à la casse (le langage C fait la différence entre un
nom en majuscules et un nom en minuscules)
28

Les constantes
• Une constante est un nombre, un caractère ou une chaîne de caractères utilisable comme valeur
dans un programme.
• Utilisez des constantes pour représenter des valeurs à virgule flottante, entières, d'énumération
ou de caractères qui ne peuvent pas être modifiées.
En langage c
Const type nomconstante=valeurconstante;

ou bien
#define nom_constante = valeur_de_la_constante ;

Exemple
#define x 40 ou bien const int x=40;
#define c 'a‘ ou bien const char c=‘a’;
Remarque: toute constante doit être déclarée avant on utilisation
29

Les fonctions

• La fonction est l'unité modulaire fondamentale en langage C.

• Une fonction est généralement conçue pour effectuer une tâche spécifique et son nom reflète

souvent cette tâche.

• Une fonction contient des déclarations et des instructions.

Type_du_resultat Nom_fonction (Type_param Nom_param,…) {

/* déclaration des variables locales */

/* instructions */

}
30

Les fonctions

Par exemple, la fonction secondaire suivante calcule le produit de deux entiers :

int produit(int a, int b) {
int resultat;
resultat = a * b;
return(resultat);
}
31

Structure d'un
programme C
32

Expression

Une expression est une suite de composants élémentaires syntaxiquement correcte

Par exemple:

x = 0

ou bien

(i >= 0) && (i < 10) && (p[i] != 0)

33

Instruction

• Une instruction est une expression suivie d'un point-virgule.

• Le point-virgule signifie en quelque sorte ``évaluer cette expression''.

• Plusieurs instructions peuvent être rassemblées par des accolades { et } pour former

une instruction composée ou bloc qui est syntaxiquement équivalent à une instruction.

• Par exemple,

if (x != 0) { z = y / x; t = y % x; }
34

Déclaration

• Une instruction composée d'un spécificateur de type et d'une liste d'identificateurs séparés par
une virgule est une déclaration.

• Par exemple,

int a;

int b = 1, c;

double x = 2.38e4;

char message[80];

• En C, toute variable doit faire l'objet d'une déclaration avant d'être utilisée.
35

Structure d’un programme en C

/* inclusion des bibliothèques */

main ( )
{
/* déclarations */
/* instructions */
}
 Chapitre 3

Types de base
Dr. Mariem MEFTEH
37

Types primitifs

• Un type de données définit une collection de données des objets et un ensemble

d'opérations prédéfinies sur ces objets
• Presque tous les langages de programmation fournissent un ensemble de types
de données primitifs
• Types de données primitifs : ceux non définis en termes d'autres types de
données
38

Les types prédéfinis

• Le C est un langage typé. Cela signifie en particulier que toute variable, constante ou
fonction est d'un type précis.

• Le type d'un objet définit la façon dont il est représenté en mémoire.

• La mémoire de l'ordinateur se décompose en une suite continue d'octets.

• Chaque octet de la mémoire est caractérisé par son adresse, qui est un entier.

• Deux octets contigus en mémoire ont des adresses qui diffèrent d'une unité.

• Quand une variable est définie, il lui est attribué une adresse.

• Cette variable correspondra à une zone mémoire dont la longueur (le nombre d'octets) est
fixée par le type.
39

Le type caractère
• Le mot-clef char désigne un objet de type caractère.
• Un objet de type char est codé sur un octet
• C'est l'objet le plus élémentaire en C
• Stocké sous forme de codages numériques
• Codage le plus couramment utilisé : ASCII
40

Le type caractère

• La table précédente donne le code ASCII des caractères imprimables.

41

Le type caractère

• Une des particularités du type char en C est qu'il peut être assimilé à un entier

 Tout objet de type char peut être utilisé dans une expression qui utilise des objets

de type entier.

• Par exemple, si c est de type char, l'expression c + 1 est valide.

• Elle désigne le caractère suivant dans le code ASCII.

• Ainsi, le programme suivant imprime le caractère 'B'.

42

Les types entiers

• Un nombre entier est un nombre sans virgule

• Le mot-clef désignant le type entier est int.
43

Les types flottants

Les types float, double et long double servent à représenter des nombres en virgule flottante.
44

Les variables booléennes

• Il n'existe pas de type spécifique pour les variables booléennes,

 Tous les types de variables numériques peuvent être utilisés pour exprimer des opérations

logiques:

• La variable logique FAUX correspond à la valeur numérique 0. La variable logique VRAI

correspond toute valeur différente de 0.

45

Affichage sur l’écran :printf()

• Le langage C utilise les fonctions de la bibliothèque stdio.h (à inclure) pour les entées/sorties.
Entrée à partir du clavier (scanf), sortie sur écran (printf),

printf(``format``, liste_de_variables);

 format: format d’écriture des variables

%d, %f, %.2f, %s, %h, …

 liste_de_variables: liste de variables, séparés par des virgules.

Exemple:
#include <stdio.h>
void main(){
float p=1.556;
int j=5;
printf(``le jour est %d ``, j);
printf(``prix : %f euros à payer avant le %d aôut \n``, p, j);
}
46
47

#include <stdio.h>
void main(){
float p=1.556;
int j=5;
printf(``le jour est %d ``, j);
printf(``prix : %f euros à payer avant
le %d aôut``, p, j);
}
 Format des nombres avec printf

Variable Instruction Exemple

%c Caractère de type char char c; printf("%c ", c);

%d ou %i Entier de type int int x; printf("%d ", x);

%x Entier de type int affiché en notation int x; printf("%x ", x);
hexadécimale
%o Entier de type int affiché en notation int x; printf("%o ", x);
octale
%u Entier non signé de type unsigned int unsigned int x; printf("%u ", x);
%hd short int short int h;
printf("%hd ", h);
%ld long int long int h; printf("%ld ", h);
%f float float m;
printf("%f ", m);
%lf double double d; printf("%lf ", d);
48
49

Exemple d’affichage

En algorithmique En langage c

#include <stdio.h>
algorithme affich
void main()
Variables
{
X:entier; r:réel; a:caractère;
int x=2;
ch:chaîne de caractères; b:booléen;
float r=3.57;
Début
char c=‘m’;
//ajouter les instructions
int b=0;
d’initialisation
printf(“x est= %d r est = %f c est = %c“,
Ecrire(“x est= “,x, “r est = “,r, “c est =
x,r,c);
“,c);
}
FIN
 Format des nombres avec printf
Un indicateur de format se construit ainsi:

%[flag][largeur][.précision]type
flag: - cadre à gauche, + cadre à droite (par défaut cadre à droite),…

largeur : nombre minimum de caractères

La précision: indique le nombre maximum de caractère d’une chaîne à imprimer. Soit le nombre de chiffres à
imprimer à droite du point décimal d’une valeur à virgule flottante, soit le nombre de chiffres à imprimer pour un
entier.
Format Résultat Description
%6d └┘ └┘ └┘ 123 Largeur minimum de champ de 6 caractères
%06d 000123 Largeur minimum de champ de 6 caractères et remplissage avec des zéros

%-6d 123 └┘ └┘ └┘ Largeur minimum de champ de 6 caractères cadrage à gauche

%6.3f └┘ 3.141 Largeur minimum de champ de 6 caractères avec trois chiffres après la virgule

50
Format Résultat Description

%6d └┘ └┘ └┘ 123 Largeur minimum de champ de 6 caractères

%06d 000123 Largeur minimum de champ de 6 caractères
et remplissage avec des zéros
%-6d 123 └┘ └┘ └┘ Largeur minimum de champ de 6 caractères
cadrage à gauche
%6.3f └┘ 3.141 Largeur minimum de champ de 6 caractères
avec trois chiffres après la virgule

51
52

Exemple sur les formats de nombres

53

Caractères spéciaux de la fonction printf

\n nouvelle ligne

\t tabulation

\v tabulateur vertical

\r retour à la ligne

\a sonnerie

\\ trait oblique

\’ apostrophe

\“ double quote
54

Lecture d’une variable au clavier

• la fonction prédéfinie scanf a pour rôle de lire une information au clavier

• scanf ("%f", &x) ;

 Comme printf, la fonction scanf possède en premier argument un format (ici "%f" )

• Exemple:

scanf ("%c", &op) permet de lire un caractère au clavier et de le ranger dans op.

• Notez le code %c correspondant au type char (n’oubliez pas le & devant op).

scanf ("%d %d", &n1, &n2) ;

 Lecture d’une variable au clavier
Variable Exemple
%c char c;
scanf("%c ", &c);
%hd short int h;
scanf("%hd ", &h);

%ld long int h;

scanf("%ld ", &h);
%f float m;
scanf("%f ", &m); %e
%lf double d; scanf("%lf ", &d);
%d ou %i int x; scanf("%d ", &x);

55
56

Exercice 1
Ecrire un programme qui calcule la somme et le produit de deux nombres

#include <stdio.h>
main()
{
int n1, n2 ;
printf ("donnez 2 nombres entiers : ") ;
scanf ("%d %d", &n1, &n2) ;
printf ("la somme est : %d ", n1+n2) ;
printf ("le produit est : %d ", n1*n2) ;
}
 Exercice

Ecrire un programme C qui permet de lire deux nombres réels, et d’afficher ensuite leur produit, avec
une précision de trois chiffres après la virgule.

57
 Exercice 3
Ecrire un programme C qui permet de permuter le contenu de deux variables entières en
passant par une troisième variable auxiliaire. Ceci et en affichant les deux variables avant et
après permutation.

58
59

Exemple de programme
Exercice:
Ecrire un programme qui calcule la racine carré d’un nombre

#include <stdio.h>
#include <math.h>
main()
{
float x ;
float racx ;
printf ("Donnez un nombre : ") ;
scanf ("%f", &x) ;
racx = sqrt(x) ;
printf ("Le nombre %f a pour racine carrée : %f\n",x,racx) ;
}
 Chapitre 5

Les operateurs

Dr. Mariem MEFTEH

 Opérateurs arithmétiques
Opérateurs bi-opérandes
+ , - , * , / , % (modulo)
Les opérandes doivent être des valeurs numériques.
Exemples

int a,b; float a,b;

a=10; b= 3 a=12.6; b= 3.0
a+b 13 a+b 13.6
a-b 7 a-b 9.6
a*b 30 a*b 37.8
a/b 3 (division euclidienne) a/b 4.2 (division réelle)
a%b 1 a%b erreur de syntaxe
 Opérateurs arithmétiques
Opérateurs unaires (un opérande)
• signe : + , -
exemple : a = -a;

• incrémentation, décrémentation : ++ (+1) , -- (-1)

exemple :
int i =1;
++i;
printf("%d",i) ; -> 2
 ++ et --
Syntaxes : ++i ou i++
• ++i : la valeur de i est d'abord incrémenté, la valeur résultat est utilisée dans
l'expression courante
• i++ : la valeur courante de i est utilisée dans l'expression courante, puis i est
incrémenté

Exemples
int i=1; i=1;
printf("i= %d\n",i); -> i=1 printf("i= %d\n",i); -> i=1
printf("i= %d\n",++i); -> i=2 printf("i= %d\n",i++); -> i=1
printf("i= %d\n",i); -> i=2 printf("i= %d\n",i); -> i=2
 Opérateurs d'affectation: Affectation simple

Syntaxe : variable = expression

la valeur de l'expression est stockée dans la mémoire à l'endroit réservé pour la
variable

Exemples :
a = 2; b=1; c=0;
a = b+c;
 la valeur de l'expression vaut la valeur affectée
 Opérateurs d'affectation: Affectation et opération

+= -= *= /= %=

Syntaxe : variable opérateur expression

équivalent à : variable = variable opérateur expression

Exemple :
int i;
i= 3;
i+=2; // même chose que i=i+2;
printf("%d\n",i); // 5
 Opérateurs relationnels

Valeur logique : 0 : faux  0 : vrai

Operateurs Relationnels :

>= , > , == , <, <= , !=

La valeur de l'expression est 1 si l'expression est vraie , 0 si elle est fausse

Exemple : 2 < 3 vaut 1 , 2 > 3 vaut 0

Remarque: Attention à la confusion : test d'égalité == et l'affectation =

67

Opérateurs logiques
Operateurs Logiques :

&& "et" logique , || "ou" logique, ! "non" logique

 Dans l'évaluation de l'expression, 0 est considéré comme la valeur logique "faux", toute valeur  0

comme la valeur logique "vraie"

 La valeur de l'expression est 1 ou 0

Exemples: 2 && 0 vaut 0 et donc est faux

2 || 0 vaut 1 et donc est vrai

!0 vaut 1

!4 vaut 0
 Opérateur conditionnel
Syntaxe :
expression1 ? expression2 : expression3 ;

à peu près équivalent à :

if (expression1)
expression2;
else expression3;

Exemple :
maximum = (x>y) ? x : y;

if (x>y)
maximum =x ;
else maximum = y;
 Chapitre 6

Structures conditionnelles

Dr. Mariem MEFTEH

 Qu'est-ce qu'une structure conditionnelle ?
On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou
non.
71

La notion de bloc

• Une expression suivie d'un point-virgule est appelée instruction.

Voici un exemple d'instruction :

a++;

• Lorsque l'on veut regrouper plusieurs instructions, on peut créer ce que l'on appelle un bloc,

c'est-à-dire un ensemble d'instructions (suivies respectivement par des points-virgules) et

comprises entre les accolades { et }.

72

L'instruction if

• L'instruction if est la structure de test la plus basique, on la retrouve dans tous les langages

(avec une syntaxe différente...).

• Elle permet d'exécuter une série d'instructions si jamais une condition est réalisée.

• La syntaxe de cette expression est la suivante :

if (condition réalisée) { liste d'instructions; }

73

L'instruction if

• la condition doit être entre des parenthèses

• il est possible de définir plusieurs conditions à remplir avec les opérateurs ET et OU (&& et ||)

Par exemple l'instruction suivante teste si les deux conditions sont vraies :

if ((condition1)&&(condition2))

• L'instruction suivante exécutera les instructions si l'une ou l'autre des deux conditions est vraie :

if ((condition1)||(condition2))

• s'il n'y a qu'une instruction, les accolades ne sont pas nécessaires...

74

L'instruction if ... else

• L'instruction if dans sa forme basique ne permet de tester qu'une condition, or la plupart du

temps on aimerait pouvoir choisir les instructions à exécuter en cas de non réalisation de la

condition...

• L'expression if ... else permet d'exécuter une autre série d'instructions en cas de non-réalisation

de la condition.

• La syntaxe de cette expression est la suivante :

if (condition réalisée) {

liste d'instructions }

else { autre série d'instructions }

75

Une façon plus courte de faire un test

Il est possible de faire un test avec une structure beaucoup moins lourde grâce à la structure

suivante :

(condition) ? instruction si vrai : instruction si faux

76
Exemple
77

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

• Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable, car

cette opération aurait été compliquée (mais possible) avec des if imbriqués.

• Sa syntaxe est la suivante :

78

L'instruction switch
79

L'instruction switch

• Les parenthèses qui suivent le mot clé switch indiquent une expression dont la valeur est testée

successivement par chacun des case.

• Lorsque l'expression testée est égale à une des valeurs suivant un case, la liste d'instructions qui

suit celui-ci est exécutée.

• Le mot clé break indique la sortie de la structure conditionnelle.

• Le mot clé default précède la liste d'instructions qui sera exécutée si l'expression n'est jamais égale

à une des valeurs.

80

L'instruction switch
81

Exercice
 Chapitre 7

Structures itératives

Dr. Mariem MEFTEH

83

Les boucles ou instructions itératives

Les instructions itératives en algorithmique, Les instructions itératives en langage C
permettent de répéter un ensemble
while (expression)
d’instructions:
{ …….
Tantque(…) ….
……..}
…….
Fintantque for ( ……..)
{…….
Pour (…) …….. ……..}
…. do
Fin Pour {……..
………..}while(expresion);
Répéter
……..
Jusqu’à………..
84

L’instruction Tant que

en algorithmique en Langage C
Tant que (condition) while (condition)
instruction1 {instruction1
….. …..
instruction n instruction n
Fin tantque }
Exemple:
Tant que la condition est vraie on i =0;
exécute le corps de la boucle, on n = 20;
s’arrête dés que la condition n’est while (i<n)
plus vérifiée {
i++;
Le corps de la boucle est exécuté }
zéro ou plusieurs fois
85

Remarques
• Il ne faut pas écrire une structure Tantque dans laquelle l’expression booléenne ne peut pas
être vraie: le programme ne rentrera jamais dans la boucle
Exemple: tant que (i>10 et i<2) ……
• De même, il ne faut jamais écrire une boucle dans laquelle le booléen ne devient jamais faux.
L’’ordinateur tourne dans la boucle et n’en sort jamais: boucle infinie
Exemple: tant que (i<10 ou i>2)…………………..
• On peut avoir des boucles tantque imbriqués. Le finTantque ou l’accolade de fin } se rapporte
toujours au dernier tantque rencontré
86

L’instruction répéter …jusqu’à

Syntaxe
do {
instructions;
} while (expression);

*expression est évaluée après chaque itération.

Si le résultat est vrai alors les instructions sont exécutées
sinon on sort de la boucle
*le bloc d’instruction est exécutée au moins une fois
exemple
i =0; n = 20;
do
{i++;
} while(i<n);
87

Exemples
Exemple1: Ecrire un programme C permettant de lire un nombre entre 1 et 10
88

Exemples
Exemple 2: Ecrire un programme en C permettant de lire deux nombre et de faire la division
(diviseur positif)
89
Boucle pour
Ce type de boucle est utilisé lorsqu’on connaît d’avance le nombre de répétions de la boucle

for(expr_init;expr_cond;compteur)
{
instructions
}

Expr_init: évaluée 1 seule fois en début de boucle, c’est l’initialisation des données
de la boucle
Expr_cond: évaluée avant chaque itération. Si vrai alors les instructions de la boucle
sont exécutées sinon la boucle est terminée, c’est la condition de la boucle
compteur: évaluée à la fin de chaque itération, elle est utilisée pour l’avancement de
la boucle
90

Exemples
Exemple: somme des 100 premiers entiers

#include<stdio.h>
void main()
{
int i,s;
s= 0;
for(i=0;i<=100;i = i+1)
{
s = s+i; / / ou s+=i;
}
printf(" s=%d \n " ,s);
}
91

Exercices:
Écrire un programme qui affiche les premiers nombres pairs (2,4,6,...)
inferieurs a 50, de trois façons différentes :
avec une boucle while (...) { ... } ;
avec une boucle do { ... } while (...) ;
avec une boucle for (...;...;...) { ... } ;
 Compléments sur les instructions de contrôle : continue

Dans une structure itérative : l'instruction continue permet d'arrêter l'itération courante sans sortie
de la boucle
Exemple: Calculer la moyenne des valeurs positives d'un tableau d'entiers.
……………

nb_valeurs=0;

somme = 0;

for (i=0;i<dim;i++) {

if (T[i]<0)

continue;

somme += T[i];

nb_valeurs ++;

moyenne = somme / nb_valeurs;

 Instruction break
• L'instruction break fait sortir de la structure de contrôle dans laquelle elle est imbriquée

• Application typique : gestion d'exception

 Différence entre continue et break
for (i = 0 ; i < 10 ; i++) {

if (i == 5) break ;

printf("%d,",i) ;

Résultat: 0,1,2,3,4,

for (i = 0 ; i < 10 ; i++) {

if (i == 5) continue ;

printf("%d,",i) ;

Résultat: 0,1,2,3,4,6,7,8,9
95
96
 Chapitre 8

Les tableaux

Dr. Mariem MEFTEH

 Tableaux
Lorsque on veut mémoriser plusieurs données de même type, on peut utiliser un tableau c-à-d on regroupe
sous un même nom plusieurs informations

Exemple de déclaration d'un tableau d'entiers

int tab[100];
• int : type des éléments du tableau
• tab : identificateur (nom du tableau)
• 100 : nombre d'éléments du tableau (dimension)
• tab peut recevoir 100 entiers indicés de 0 à 99 (attention !)
• le premier est tab[0]
• le second tab[1]
• ..
• le dernier tab [99]
 Tableaux
• Chaque élément du tableau est accessible par un indice qui doit être de type entier, quelque soit le
type des éléments du tableau
• Exemples :
int i ;
tab[2]  3eme élément du tableau
tab[2+3]  6eme élément du tableau
tab[i]  i+1eme élément du tableau
• Exemples :
• stocker les 100 premiers nombres pairs : 0,2,4,6...

int i, t[100];
for (i=0; i < 100; i=i+1)
t[i]= 2*i;
 Tableaux
Remarques:

1/ chaque élément du tableau s'utilise comme une variable

tab[3] = 2;

2/ le nombre maximum d'éléments du tableau (dimension)

1/ doit être fixé à la compilation

2/ ne peut être modifié pendant l'exécution

 Parcours des éléments d’un tableau
• Parcours du premier au dernier
int i;
float t[100];
for (i=0; i < 100; i=i+1) // ou bien for (i=0; i <= 99; i=i+1)
t[i]= ……;

• Parcours du dernier au premier

int i;
float t[100];
for (i=99; i >= 0; i=i-1)
t[i]= ……;
 Exemples

Mémorisation des 100 premiers nombres pairs et impairs:

int pairs[100], impairs[100];
int i;
for (i=0; i<100;i=i+1) {
pairs[i]=2*i;
impairs[i]=2*i+1;
}
 Tableaux
• Initialisation à la compilation
1 2 3 4 5 6 7 8 9 10
int t[10] = {1,2,3,4,5,6,7,8,9,10};
0. 0.25 3.14 2.57
float x[4] = {0.,0.25,3.14,2.57};
char couleur[4]= {'r','v','b','j'}; r v b j
char texte[10]="abcd"; a b c d \0 ? ? ? ? ?
int t1[10] = {1,2,3}; 1 2 3 ? ? ? ? ? ? ?

• Dimension par défaut:

int t[ ]={0,0,0}  dimension =3
char t [ ]={'r','v','b','j'};  dimension=4
char t[ ]="abcd"  dimension=5

par contre int t[ ] sans initialisation est incorrect

 Tableaux
Accès aux éléments d'un tableau

int t[50];

syntaxe 1
// accès à la (i+1)ème case avec i compris entre 0 et 49
t[i];

syntaxe 2
puisque t est l'adresse de la première case :
t[0]  *t
t[1]  *(t+1)
…
t[i]  *(t+i)
105

Remarques
106
107

Compte rendu
108

Correction
109

Recherche dans un tableau unidimensionnel

110

Recherche dichotomique itérative dans un tableau trié