‫‪Programmation C++‬‬

‫إذا كنت ال تعلم إلى أين أنت ذاهب‪ ،‬فإن أي طريق سيوصلك إلى هناك‬
‫توماس كرليل‬

‫‪M. EL AMRANI‬‬
 Programme et langage de
programmation
Un programme est un ensemble d'instructions ou de codes
informatiques qui permettent à un ordinateur ou à un système
informatique d'effectuer des tâches spécifiques.
Ces instructions sont écrites dans un langage de programmation, tel que :

✓ langage C/C++ ;
✓ langage Fortran ;
✓ langage Python ;
✓ langage Java ;
✓ ...
 Avantages et Inconvénients
du langage C/C++

Avantages du langage C++ ::

➢Efficacité et performance élevée ;
➢Contrôle précis de la mémoire et des registres matériel ;
➢ Adapté aux applications systèmes, aux jeux, et aux applications
temps réel ;
➢ Très bien adapté pour les systèmes embarqués ;
➢ Bibliothèques standard très riche ;
➢ Prise en charge de la programmation orientée objet ;
➢…
 Langages dérivés de C

Le langage C a donné naissance à de nombreux langages dérivés :

➢ C++ est une extension du langage C qui ajoute la POO.

Il est souvent utilisé pour le développement de logiciels complexes,
de jeux vidéo et d'applications système ;

➢ C# (C Sharp) : C’est un langage de programmation développé par

Microsoft ; il est principalement utilisé pour le développement des jeux
avec Unity et d'applications web avec [Link].

➢ Objective-C : pour le développement d'applications iOS et macOS.

 Langages dérivés de C

➢ Langage D : C’est un langage qui combine des fonctionnalités

modernes telles que la gestion automatique de la mémoire.
Il est conçu pour être efficace et sûr.

➢ Go (ou Golang) : C’est un langage créé par Google. Il se caractérise

par sa simplicité, ses performances et sa gestion automatique
de la mémoire.

➢ Rust ;
➢ Chapel ;
➢ Perl ;
➢ …
 Historique du C et C++

1972 : Création du langage C par Denis Ritchie.

1978 : Définition rigoureuse du langage C par Ritchie et Kernighan.

1989 : Normalisation du C par ANSI (American National Standard

Institute).

1982 : Création du langage C++ par Bjarne Stroustrup.

1989 : Publication de la première version du C++.

1998 : Publication de la norme définitive de C++.

 Structure d’un programme C/C++
C/C++ est un langage structuré. Un fichier source doit
satisfaire les conditions suivantes :

✓ Déclaration des includes ;

✓ Le programme est constitué par une ou plusieurs fonctions

dont la fonction principale main ;

✓ Chaque fonction est constituée par un ou plusieurs blocs

situés entre accolades ;

✓ Chaque bloc est constitué par une ou plusieurs instructions.

✓ Toutes les variables, utilisées dans le programme, doivent

être déclarées avec un type.
 ‫‪Types de base‬‬

‫ال تطالب بأن تكون األشياء أيسر‪ ،‬بل أطلب أن تكون أنت األفضل‬
‫جيم رون‬
 Les types de base
En C/C++, toute variable doit être déclarée avec son type c-à-d la
manière dont elle se fait codée en mémoire. La connaissance du type
est nécessaire pour la plupart des opérations que subit la variable.

Les différents groupes de type :

➢ types simples :
✓ types de données entières ;
✓ types à virgule flottante ;
✓ bool ;
✓ pointeur.

➢ types agrégés caractérisés par un ensemble de valeur :

✓ tableaux ;
✓ structures ;
✓ classes ;
 Les types de base

Les types de données entières :

✓ char ;
✓ short ;
✓ long ;
✓ int .
 Les types de base

Le type char est utilisé pour représenter un caractère

quelconque. C’est, en faite, le code ASCII ( American
Standard Code for Information Interchange).
Le type char stocke les données sur 1 octet (=8 bits), soit
28 = 256 valeurs : [-128, 127].

Exemple :
Si le caractère A est stocké sous forme char, l’ordinateur
n’écrit pas le signe A, mais son code ASCII : 65.
 Les types de base
Le type short : ce type permet de stocker des données sur 2 octets, soit
16 bits. Avec 16 bits, on peut former 216= 65536 combinaisons.
Le type short permet donc de coder les nombres entre -32768 et 32767.

Le type long : ce type permet de stocker des données sur 4 octets, soit
32 bits, avec lesquels on peut former 232= 4294967296
combinaisons.
Le type long permet donc de coder les nombres entre -2147843648 et
2147843647.

Le type int : ce type n'occupe pas un nombre figé d'octets. Son

occupation mémoire dépend de l’ordinateur utilisé et peut valoir 2 ou
4 octets.
 Les types de base
Les types de données réelles :
✓ float;
✓ double ;
✓ long double.

Les nombres réels sont stockés autrement que les nombres entiers.
Ils sont dits à virgule flottante. Ces nombres sont approchés par une
quantité de la forme :
x = [Link]

➢S est le signe de la variable x. Ainsi S vaut -1 ou +1 ;

➢m est la mantisse ;
➢e est l’exposant
 Les types de base

Le type float : un nombre de type float est codé sur 4 octets (32 bits)
sous la forme suivante :

Bit de signe Exposant (e) Mantisse (m)

(S) (sur 8 bits) (sur 23 bits) x = [Link]

Exemple : le nombre 15.6 est représenté par : +0.156 102

La plage de valeur d’un nombre de type float : ±3.4 10-38 à ±3.4 1038
 Les types de base

Le type double : un nombre de type double est codé sur 8 octets (64
bits) sous la forme suivante :

Exposant Mantisse x = [Link]

Bit de signe
(sur 11 bits) (sur 52 bits)

La plage de valeur d’un nombre de type double : ± 1.7 10-308 à ± 1.7 10308
 Les types de base

Le type long double : un nombre de type long double est codé sur 10
octets (80 bits) sous la forme suivante :

Exposant Mantisse x = [Link]

Bit de signe
(sur 15 bits) (sur 64 bits)

La plage de valeur d’un nombre de type long double :

±3.4 10-4932 à ±3.4 104932
 Les types de base

Le type bool : Ce type est formé de deux valeurs 1 et 0.

bool x : x ne peut donc prendre que les valeurs 0 ou 1.

En C++, une variable booléenne x prend soit la valeur 0 ou

1, soit les mots clé false ou true.
 Les types de base

Le type pointeur :
Un pointeur est une donnée qui mémorise l'adresse d'une variable.
le pointeur correspondant à i est &i.
D’une manière générale, un pointeur est déclaré de la manière suivante:

type *p

Exemple : float *x. (veut dire que x est un pointeur (une adresse) dont
le contenu *x est réel de type float).
 Les types de base

Remarque sur les types unsigned :

Les types déclarés auparavant peuvent être signé ou non.
Dans ce dernier cas (pas de signe) la plage de variation
est doublée.

Exemple :
La déclaration "long i" autorise à i les valeurs :
[- 2147843648, 2147843647 ], alors que

la déclaration "unsigned long i" autorise à i les valeurs:

[0,4295687295].
 Les types de base

Remarque sur les constantes :

Une constante est une donnée dont la valeur ne peut varier.
Cette donnée peut être un nombre, un caractère ou une
chaine de caractères.

Pour déclarer une variable comme étant une constante, il

suffit d'ajouter, au moment de la déclaration, le mot const
avant le type de la variable et de donner une valeur à celle-
ci.

Exemple : const int x=4;

 ‫‪Entrées-Sorties‬‬

‫العلم ال ينمو من خالل األجوبة المسكتة وإنما من خالل األجوبة التي تثير مزيدا من األسئلة‬
‫عبد الكريم بكار‬
 Les entrées-sorties

Les fonctions d’entrées-sorties permettent d’écrire des

caractères et des valeurs sur l’écran, ainsi que de les saisir
à partir du clavier.

On distingue :
➢Les entrées/sorties formatées de C/C++
(assurées par les fonctions : scanf et printf ) ;

➢Les entrées/sorties non formatées

(en C++, elles sont assurées par les fonctions cin et cout);
 Les entrées-sorties

En C++, pour lire des données, on utilise la fonction : cin

Exemple :
cin>>x; //la valeur saisie au clavier sera affectée à x.

Pour afficher des données, on utilise la fonction : cout

Exemple :
cout<<x ; //affichage de la valeur de x.
 Les sorties formatées
Remarques concernant la fonction cout

Remarque 1 :
Pour afficher une phrase (par exemple : bonjour tout le monde), il
suffit de la mettre entre guillemets :

cout<<"bonjour tout le monde";

Remarque 2 :
Pour revenir à la ligne soit on utilise "\n" soit on utilise endl.
Les trois instructions suivantes sont équivalentes :
✓cout << "bonjour \n" ;
✓cout << "bonjour" << "\n" ;
✓cout << "bonjour" << endl ;
 Les sorties formatées
Remarques concernant la fonction cout
Remarque 3 :
Il existe des instructions qui permettent d’afficher les valeurs entières
sur l’une des bases suivantes :
1 : bool soit sous forme d’un entier 0 ou 1 soit sous forme
true et false en utilisant le mot clé boolalpha ;
8 : octal en utilisant le mot clé oct ;
10 : décimal qui est la valeur par défaut ;
16 : hexadécimal en utilisant le mot clé hex.

La valeur de la base reste la même tant qu’on ne la modifie pas.

Exemple :
int x =12000, y =1 ;
cout << x << "/n" ; //la valeur affichée sera : 12000.
cout<<hex<<x<< "/n" ; //la valeur affichée sera : 2000.
cout<<oct<<x<< "/n" ; //la valeur affichée sera : 27340.
cout<<boolalpha<<y << "/n" ; //la valeur affichée sera : true.
cout <<noboolalpha <<y<< "/n" ; //la valeur affichée sera : 1.
 Les sorties formatées
Largeur de champ minimale

Le C++ utilise le manipulateur setw(M) pour afficher les variables sous

un gabarit souhaité, où M est la largeur minimale d’affichage.
Le manipulateur setw nécessite l’incorporation du fichier en tête
<iomanip>.

Exemple :
int i = 171 ;
cout << setw(5) << i ; la valeur affichée sera : ^^171.
cout << setw(4) << i ; la valeur affichée sera : ^171.
cout << setw(2) << i ; la valeur affichée sera : 171.

Remarque :
setw manipule uniquement le gabarit de la prochaine information à écrire.
 Les sorties formatées
Précision d’affichage

Pour fixer la précision d’affichage, le C++ utilise le manipulateur

setprecision(M) ; où M est le nombre de chiffres significatifs.

Exemple :
float pi =3.141593 ;
cout << pi <<endl ; //la valeur affichée sera : 3.14159
cout << fixed ;
cout << setprecision(1) <<pi <<endl ; //la valeur affichée sera : 3.1
cout << setprecision(3) <<pi <<endl ; //la valeur affichée sera : 3.141
cout << setprecision(5) <<pi <<endl ; //la valeur affichée sera : 3.14159
 Les sorties formatées
Précision d’affichage en C++

Sans utilisation du manipulateur "fixed", M joue le rôle du nombre

de chiffres à afficher.

Exemple :
float pi =3.141593 ;
cout << setprecision(1) <<pi <<endl ; //la valeur affichée sera : 3
cout << setprecision(3) <<pi <<endl ; //la valeur affichée sera : 3.14
cout << setprecision(5) <<pi <<endl ; //la valeur affichée sera : 3.1415
cout << setprecision(7) <<pi <<endl ; //la valeur affichée sera : 3.141593
 Les sorties formatées
Précision d’affichage en C++

fixed permet aussi d’afficher en notation flottante si elle était en notation

scientifique. En effet : pour afficher un réel en notation scientifique on
utilise le manipulateur scientific et si, ensuite, on souhaite l’affichage
habituel on utilise le manipulateur fixed.

Exemple :
float pi =3.1415 ;
float x = 63.987 ;
cout << pi <<endl ; //la valeur affichée sera : 3.1415
cout << scientific << pi <<endl ; //la valeur affichée sera : 3.1415e00
cout << x <<endl ; //la valeur affichée sera : 6.3987e01
cout << fixed <<endl ;
cout << x <<endl ; //la valeur affichée sera : 63.987
‫‪Les Opérateurs‬‬

‫سر السعادة ليس هو أن تفعل ما تحب‪ ،‬ولكن أن تحب ما تفعل‬

‫جيمس باري‬
 Les opérateurs
Les opérateurs sont des symboles qui permettent d’effectuer
différentes opérations.

Les opérateurs sont très nombreux, on peut citer :

✓les opérateurs arithmétiques ;
✓les opérateurs de comparaison ;
✓les opérateurs de logique ;
✓les opérateurs de bits ;
✓les opérateurs d’affectation ;
✓les opérateurs conditionnels ;
✓les opérateurs séquentiels ;
✓les opérateurs de taille ;
✓les opérateurs d’adresse ;
✓les opérateurs de cast ;
✓…
 Les opérateurs
Opérateurs arithmétiques

Ces opérateurs permettent d’effectuer des calculs élémentaires sur

leurs opérandes.

En plus des opérateurs connus : +, -, * et /, il existe aussi :

✓l’opérateur % qui permet de calculer le reste entier d’une

division ;

✓l’opérateur "–" (signe -) qui permet de changer le signe de

l’opérande.
 Les opérateurs
Opérateurs de comparaison
(ou opérateurs relationnels)

Ces opérateurs permettent de comparer les valeurs de leurs

opérandes :
✓x = =y : vaut 1 si x est égal à y et vaut 0 sinon.
✓x ! =y : vaut 1 si x est différent de y et vaut 0 sinon.
✓x <y : vaut 1 si x est inférieur à y et vaut 0 sinon.
✓x >y : vaut 1 si x est supérieur à y et vaut 0 sinon.
✓x< =y : vaut 1 si x est inférieur ou égal à y et vaut 0 sinon.
✓x> =y : vaut 1 si x est supérieur ou égal à y et vaut 0 sinon.

Le résultat de la comparaison est de type logique c'est-à-dire soit

vrai (true) soit faux (false).
 Les opérateurs
Opérateurs de comparaison
(ou opérateurs relationnels)
Exemple 1 :
x=3 , y=5;

(x = = y) = 0 (false)
(x < y) = 1 (true)

(x!=y) = 1
(x<=y) = 1
 Les opérateurs
Opérateurs logiques

Les opérateurs logiques effectuent les opérations de logique.

Trois opérateurs sont proposés par C/C++ :

✓ L’opérateur "&&" représente la connexion ET.

Le résultat vaut true (1) si les deux opérandes sont true et vaut false(0)
dans les autres cas ;

✓ L’opérateur "||" représente la connexion OU.

Le résultat vaut 0 si les deux opérandes valent 0 et 1 dans les autres
cas.

✓ L’opérateur "!" représente la connexion Non.

Le résultat vaut 1 (true) si l’opérande est 0 (false) et vaut 0 si
l’opérande est 1.
 Les opérateurs
Opérateurs logiques

Exemples :

1- ((5<7) && (3>2)) = 1

2- ((5<7) || (3<2)) = 1

3- !(2>0) = 0
 Les opérateurs
Opérateurs d’affectation

Les opérateurs disponibles par C/C++ sont :

➢l’opérateur "++" désigne l’augmentation de 1 ;
➢l’opérateur "--" désigne la diminution de 1 ;
➢l’opérateur "=" désigne l’affectation simple ;
➢l’opérateur "+=" désigne l’affectation avec addition ;
➢l’opérateur "-=" désigne l’affectation avec soustraction ;
➢l’opérateur "*=" désigne l’affectation avec multiplication.
➢l’opérateur "/=" désigne l’affectation avec division.
➢l’opérateur "%=" désigne l’affectation avec opération de reste.
 Les opérateurs
Opérateurs d’affectation
Exemple :
float x =3
x-=5 ➔ x = x-5 = -2.

x =3
x* =5 ➔ x = x*5 =15.

x =3
x /= 5 ➔ x = x/5 =0.6.

x=3
x % =2 ➔ x = x % 2 = 1.
 Les opérateurs
Opérateurs d’affectation

Remarque sur les préfixes et les postfixes

Dans une instruction qui contient en même temps l’opérateur "=" et
l’un des opérateurs : ++, --, le résultat obtenu est différent
suivant que l’opérateur est préfixe ou postfixe, c'est-à-dire suivant que
l’opérateur est avant ou après l’opérande.

Exemple :
L’instruction y =x++ est différente de l’instruction y=++x.

Dans y = x++ : la variable y est affectée à la variable x, ensuite x

est incrémenté, soit :
y=x ;
x++ ;
 Les opérateurs
Opérateurs d’affectation

Dans y = ++x : on commence par faire augmenter la valeur de x.

Ensuite, cette nouvelle valeur est affectée à y, soit :
x++ ;
y=x;

Remarque :
Pour les opérations d’affectation, l’opérande gauche doit être une
Lvalue.

Une Lvalue est une expression désignant une adresse dans la mémoire
de l’ordinateur, par exemple le nom d’une variable, contrairement à une
constante qui n’est pas une Lvalue et donc ne peut être dans la partie
gauche d’une affectation.
 Les opérateurs
Opérateur conditionnel "?"

L’opérateur "?" utilise trois opérandes de type expressions, sous la

forme :

expression1 ? expression2 : expression3

si expression1 vaut true, l’expression complète prend la valeur de

expression2 sinon elle prend la valeur de expression3.

Exemple :
x =10, y =5.
L’expression (x !=y) ? x : y vaut 10
alors que l’expression (x= =y) ? x : y vaut 5.
 Les opérateurs
Opérateur séquentiel

L’opérateur séquentiel ou opérateur virgule "," permet de rassembler

de manière syntaxique deux expressions en une seule.

Exemple :
L’instruction :
int x ;
int y ;

est équivalente à :
int x,y ;
 Les opérateurs
Opérateur de dimension

L’opérateur de dimension "sizeof" calcule l’occupation mémoire

en octets requise par une variable ou par un type de données.

Exemple :
cout <<sizeof(int) <<endl ;
int x ;
cout <<sizeof(x) <<endl ;
Dans les deux cas, le résultat affiché est 4 qui indique la mémoire
occupée par un int.
 Les opérateurs
Opérateur de moulage (CAST)

L’opérateur de moulage (CAST) permet de convertir explicitement

le type d’une donnée en un autre type.

Exemple
int i,j ;
i=3; j=2;
i/j = 1;
(float)i/j=1,5;
 Les opérateurs
Priorités des opérateurs

Il y a 15 priorités allant de 1 à 15. Le niveau 15 est la priorité la plus élevée

Le tableau ci-dessous résume les priorités de tous les opérateurs.

Désignation Symbole d’opérateur priorité ordre le + élevé est

Parenthèse () [] 15 de gauche vers la droite

Opération unaire
Opérateur Cast 14
Opérateur de taille sizeof 14
-Opérateur de négation
arithmétique - 14
-Opérateur logique ! 14
Opérateur décrément -- 14
Opérateur incrément ++ 14
 Les opérateurs
Priorités des opérateurs

Opération binaire et ternaire

Opérateurs * / % 13 de gauche vers la droite
Arithmétiques
+ - 12 de gauche vers la droite

Opérateurs de > >= < <= 10 de gauche vers la droite

comparaison == != 9 de gauche vers la droite
opérateurs logiques && 5
|| 4
opérateurs ? : 3
conditionnels
(ternaire)
Opérateurs = += -= *= /= %= 2 de droite vers la gauche
d’affectation

Opérateur séquentiel , 1
‫‪Structures de contrôle de flux‬‬

‫ال فائدة في أن تقف في الظل و تشكو من عدم إشراق الشمس عليك‬

‫ماجون‬
 Structure de contrôle de flux

Les structures de contrôle de flux sont des instructions qui

permettent :

➢de rendre l’exécution de certaines instructions dépendantes

d’une certaine condition. Il s’agit d’instruction alternative
ou instruction de test ;

➢de répéter certaines phases de traitement. On parle

d’instructions répétitives ou itérations ;

➢de fournir des possibilités diverses de branchement

inconditionnels. Il s’agit d’instructions de branchement.
 Structure de contrôle de flux
Instructions alternatives

Les structures alternatives permettent d’exécuter certaines

instructions sous conditions. C/C++ propose plusieurs cas :

1- l’instruction if ;

2- test avec alternative (if-else) ;

3- test multiple (switch).

 Structure de contrôle de flux
Instructions alternatives
Instruction if
Elle permet de ne faire exécuter des instructions que si une certaine
condition est satisfaite.

La syntaxe de l’instruction if est la suivante :

if(<condition>) <instruction> ;

ou encore :

if(<condition>)
{
<instructions> ;
}
 Structure de contrôle de flux
Instructions alternatives
Instruction if
Exemple 1 :
if(x = = 0) cout<<"x est nul" ;
if(x !=0) cout<<"x est non nul" ;

Exemple 2 :
if(!x ) cout<<"x est nul" ;
if( x) cout<<"x est non nul" ;

Exemple 3 :
if(x >y && x>0) cout<<"x est positif et supérieur à y" ;
 Structure de contrôle de flux
Instructions alternatives
Test avec alternative (if-else)
L’instruction if-else permet d’exécuter des instructions si une certaine
condition est satisfaite et d’exécuter d’autres instructions sinon.
La syntaxe de l’instruction if-else est la suivante :
if(<condition>) <instruction> ;
else < instruction > ;
ou encore :
if(<condition>)
{
<instructions>
}
else
{
<instructions>
 Structure de contrôle de flux
Instructions alternatives
Test avec alternative (if-else)

Exemple 1 :
if(x = = 0) cout<<"x est nul" ;
else cout<<"x est non nul" ;

Exemple 2 :
if(x>y ) cout<<"x est plus grande que y" ;
else if (x<y)cout<<"x est plus petite que y " ;
else cout<<cout<<"x est égale à y";
 Structure de contrôle de flux
Instructions alternatives
Test multiple "switch"

L’instruction switch traite le cas où il faudrait choisir entre

plusieurs possibilités.

La syntaxe de l’instruction switch est :

switch(<expression>)
{
case cste1 : <instruction1> ;
case cste2 : <instruction2> ;
…
case csteN : <instructionN> ;
default : <instruction> ;
}
 Structure de contrôle de flux
Instructions alternatives
Test multiple "switch"
Exemple :
main()
{
int i ;
cout<<"donner un nombre entier compris entre 10 et 12"<<endl
cin>> i ;
switch(i)
{
case 10 : cout<<"votre nombre est 10"; break ;
case 11 : cout<<"votre nombre est 11"; break ;
case 12 : cout<<"votre nombre est 12"; break ;
default : cout<<"votre nombre est erroné" ; break ;
}
 Structure de contrôle de flux
Instructions répétitives

Les instructions répétitives, appelées aussi itérations ou encore

boucles, permettent de faire exécuter plusieurs fois certaines
instructions.

Trois instructions répétitives sont proposées par le langage C/C++ :

1- la boucle while ;

2- la boucle do-while ;

3- la boucle for.
 Structure de contrôle de flux
Instructions alternatives
Instruction "while"
L’instruction while permet de faire répéter l’exécution d’instructions
tant qu’une certaine condition est remplie.

La syntaxe de while est :

while (<expression>) <instruction>

ou encore :

while (<expression>)
{
<instructions>
}
 Structure de contrôle de flux
Instructions alternatives
Instruction "while"
Exemple :
int z =3 ;
while (z>0)
{
cout<<"z= "<< z<<endl;
z-- ;
}
 Structure de contrôle de flux
Instructions alternatives
Instruction "do-while"
La boucle do-while teste la condition après exécution de
l’instruction du corps de la boucle.
La syntaxe de cette boucle est :
do <instruction>
while (<expression>) ;

ou encore :

do
{
<instructions>
}
while (<expression>) ;
 Structure de contrôle de flux
Instructions alternatives
Instruction "do-while"
Exemple :
int z =3 ;
do
{
cout<<"z="<<z<<endl;
z-- ;
}
while (z>0);

Avec do-while, on rentre au moins

une fois dans la boucle
 Structure de contrôle de flux
Instructions alternatives
Instruction "for"
Tout comme l’instruction while, for est une boucle qui teste une
condition avant d’exécuter les instructions.
Sa syntaxe est :
for(<expression1> ;<expression2> ;<expression3>)<instruction>
ou encore :
for(<expression1> ;<expression2> ;<expression3>)
{
<instructions>
}
où :
<expression1> est une expression qui initialise les variables ;
<expression2> est la condition de bouclage ;
<expression3> est une expression qui permet de réinitialiser les variables.
 Structure de contrôle de flux
Instructions alternatives
Instruction "for"
Exemple :
for(z=3 ; z>0 ;z--) cout<<"z="<<z<<endl ;

Remarque :
<expression1> et <expression3> peuvent initialiser plusieurs
variables en même temps :

for(k=1, i=0, j=0 ; j<10 ; k++, j++)

{
i=i+k ;
…
}
 Structure de contrôle de flux
Instructions de branchement

Les instructions de branchement transfèrent le contrôle

du programme d’une instruction à une autre.

Nous examinerons les instructions :

➢ break ;

➢ continue ;

➢ goto.
 Structure de contrôle de flux
Instructions alternatives
Instruction "break"
Cette instruction provoque l’arrêt avant terme des instructions
des boucles for, while, do-while et swich.

Exemple :
for(i =-100 ; i<100 ; i++)
{
x =(i*0.01/3.1415;
y=cos(x);
if(fabs(y) <0.0001)break;
}
 Structure de contrôle de flux
Instructions alternatives
Instruction "continue"
L’instruction continue n’est possible qu’à l’intérieur des boucles
for, while et do-while. Elle permet de sauter un seul passage dans
la boucle et reprendre le prochain passage.

Exemple :
int x = 0 ;
while (x<20)
{
x++;
if(x%2= =0)continue;
cout<<x<<endl;
}
 Structure de contrôle de flux
Instructions alternatives
Instruction "goto"
L’instruction goto provoque un saut à un endroit du programme
repéré par une étiquette (label). Le programme continue alors à
l’instruction qui se trouve à cet endroit.

Exemple :
int i,x = 0;
for(i=0 ;i<100 ;i++)
{
x=x+i;
if(x>50)goto a ;
}
…
a : cout<<"la valeur de i est "<<i;