3 - TP Introduction A L'algorithme

TRAVAUX PRATIQUES INTRODUCTION A
L’ALGORITHME
Installation et prise en main de l’IDE

Semestre I Code::Blocks 20.03
Niveau 1 Année:
Licence Info sous Windows
DUT Info IG
DUT Info Maintenance
Code::Blocks 1. C’est quoi Code::Blocks ?
 Code::Blocks est un IDE (Environnement de Développement Intégré) libre et gratuit,

disponible sous Windows , Mac et Linux. Il n' est disponible pour le moment qu'en anglais.
 Vous pouvez le télécharger sur le site http://www.codeblocks.org , choisissez la version :

codeblocks-20.03mingw-setup.exe qui à la particularité de posséder son propre compilateur le
GNU GCC Compiler .
 Télécharger le et installer en suivant les étapes suivantes:
13/04/2023 2
Code::Blocks 2. Installation et prise en main Code::Blocks ?
Veillez à
vérifier que
le MinGW
Compiler existe
dans votre
version.
Il ne vous reste plus

qu’à cliquer à
chaque fois sur
« Next »
13/04/2023 3
Interface d’accueille : Barre
d’outils
Zone
d’édition
Exploreur
de fichier du
projet
Zone de
notification
13/04/2023 4
Création un nouveau projet
Pour créer un nouveau projet , c'est très simple: allez dans le menu File / New / Project.
Dans la fenêtre qui s'ouvre (fig. si dessous), choisissez « Console application ».
Cliquer Sélectionner
sur Go C++
13/04/2023 5
Donner un
nom a votre
projet
Choisir un
Compilateur
Choisir un
emplacement
13/04/2023 6
Compiler et
exécuter le
programme Code::Blocks vous
offre un petit code
que vous pouvez
exécuter
S’il n’y pas d’erreur

vous verrez le
terminal suivant Vérifier les
notifications
13/04/2023 7
Fenêtre d’exécution (DOS)
Cette fenêtre s’affichera à chaque fois que nous exécuterons nos programme.
13/04/2023 8
Si vous rencontrez un problème de compilateur, régler ce souci en procédant comme suit :
Aller dans le menu Settings > Compiler…
Sélectionner
le GNU GCC
Compiler
Ensuite
cliquer sur
ce bouton
13/04/2023 9
L’ALGORITHME
Les concepts de bases du

Semestre I
Niveau 1er Année:
langage de programmation
Licence Informatique
DUT Informatique de gestion
DUT Maintenance informatique
 Prérequis
- Connaissances de base en Algorithmique.
 Objectifs du cours
- Apprendre les concepts de base du langage C et C++.
- Maitriser l’IDE Code::Blocks 20.03
13/04/2023 1
Sommaire
 Généralités
1. Quelques repères historiques
2. Doit-on apprendre d’abord le langage C avant d’aborder le C++ ?
3. Le langage C++ et la programmation orientée objet
4. Construction d’un programme C++
Mon premier programme en C++

1. Structure élémentaire d’un programme C++
2. Mon 1er programme dans l’IDE Code::Blocks 20.03
3. Eléments d’un programme C++
Les structures de contrôle

1. Les blocs d’instructions
2. Le traitement alternatif (les tests)
3. Le traitement répétitif (les boucles)
4. Les variantes de la boucle for
5. Les instruction break et continue
6. Remarques générales sur les boucles
13/04/2023 1
Généralité 1. Quelques repères historiques
À l'origine, un ordinateur ne comprenait que le langage binaire : un programme était constitué d'une suite de
0 et de 1. Le programmeur devait lui-même traduire son programme sous cette forme.
En 1950, Alan Turing et Maurice V. Wilkes de l'université de Cambridge branchent un clavier à un

ordinateur, il est dorénavant possible de rentrer des mots associés au langage machine. Par exemple : mov,
load, sub… Ces mots ne sont pas compris par l’ordinateur qui ne comprend que le langage binaire. Il faut
alors un « assembleur » qui transforme le code en langage binaire.
La nécessité de créer un langage de haut niveau se fait sentir, le FORTRAN (FORmula TRANslator,
traducteur de formules) est créé en 1957. Il est utilisé pour des programmes mathématiques et scientifiques.
En 1970, Ken Thompson, créa un nouveau langage : Le B, descendant du BCPL (Basic Combined
Programming Language, créé en 1967 par Martin Richards). Son but était de créer un langage simple,
malheureusement, son langage fut trop simple et trop dépendant de l’architecture utilisée…
En 1971 Dennis Ritchie commence à mettre au point le successeur du B, le C. Le résultat est convaincant :
Le C est totalement portable (il peut fonctionner sur tous les types de machines et de systèmes), il est de bas
niveau (il peut créer du code aussi rapide que de l’assembleur) et il permet de traiter des problèmes de haut
niveau. Le C permet de quasiment tout faire, du driver aux jeux.
13/04/2023 13
Le C devient très vite populaire, tout le monde veut créer sa version. Beaucoup de compilateurs qui voient le
jour sont incompatibles entre eux et la portabilité est perdue. Il est décidé qu’il faut un standard pour le C.
l'ANSI (American National Standards Institute) s’en charge en 1983. La plupart des compilateurs se
conforment à ce standard. Un programme écrit en C ANSI est compatible avec tous les compilateurs.
Il manque la programmation orientée objet (P.O.O) au C. C’est pourquoi, Bjarne Stroustrup des
laboratoires Bell crée le C++. Le développement a commencé au début de années 80. Il construit donc le C++
sur la base du langage C. Le C++ est capable de compiler un programme C, garde donc une forte
compatibilité avec le C.
Couche prenant en
Noyau
charge la P.O.O
C++ C
Depuis sa conception, le langage C++ a évolué, il a été normalisé en 1998 par l’ANSI et l’ISO (International
Standards Organisation), on parle du langage ANSI C++ .
13/04/2023 Note: Les langages C et C++ sont les langages les plus utilisés dans le monde de la 14
Généralité 2. Doit-on d’abord apprendre le langage C avant d’aborder le C++ ?
Le fait que le C++ englobe le langage C laisse penser qu’il est nécessaire d’apprendre le langage C avant
d’aborder le C++, et bien, la réponse de Bjarne Stroustrup est la suivante : il est inutile d’apprendre le
langage C, il est même préférable de commencer directement par le langage C++. Apprendre le C++ c’est
essentiellement apprendre le C.
Le C++ a apporté par rapport au C les notions suivantes : Le C++ est un langage multi-paradigme. Il
• les concepts orientés objet; supporte essentiellement les paradigmes
• les références ; suivants :
• la vérification stricte des types ;
 programmation procédurale ;
• les valeurs par défaut des paramètres de fonctions ;
• la surcharge de fonctions (plusieurs fonctions portant  programmation structurée ;
le même nom se distinguent par le nombre et/ou le
 programmation orientée-objet ;
type de leurs paramètres) ;
• la surcharge des opérateurs (pour utiliser les  programmation générique ou méta-
opérateurs avec les objets) ;
programmation ;
• les templates de classes et de fonctions ; les
constantes typées ;  programmation 'lambda-closure'
• la possibilité de déclaration de variables entre deux
instructions d'un même bloc.
13/04/2023 15
Généralité 3. Le langage C++ et la programmation orienté objet
La programmation orienté objet (P.O.O) est une nouvelle méthode de programmation qui vise à développer
des logiciels réutilisables, cela veut dire qu’en disposant d’une bibliothèque de composants variées on peut
construire un nouveau logiciel.
La programmation orienté objet (P.O.O) est un module qui vous sera

enseigné au 2ime semestre de votre cursus de formation au sein du
CFI-CIRAS
13/04/2023 16
Meilleurs langages de programmation en 2021 selon l'IEEE
13/04/2023 17
Généralité 4. Construction d’un programme C++
L’écriture d’un programme passe obligatoirement par l’étape d’analyse et d’élaboration d’un algorithme,
c’est cet algorithme qu’on traduit dans un langage de programmation pour obtenir un programme.
a- Ecriture du programme
Pour écriture un programme, il vous faut un éditeur de texte qui peut être ou non intégré à votre
compilateur, la commande EDIT du DOS ou le Bloc notes de Windows sont bien adaptés à la saisie du
code programme.
Une fois votre code saisi, sauvegardez-me avec l’extension « .cpp » pour que le compilateur C++ le
prenne en charge.
b- Ecriture du programme
Une fois le programme écrit, on obtient ce qu’on appelle le fichier source. Il faut par la suite le
compiler, cela nous permet de détecter les erreurs de syntaxe ou autres si elles existent. Sinon,
l’opération de compilation permet de générer un fichier objet ( extension « .obj »).
La plupart des compilateur actuels proposent un environnement de développement intégré (IDE) basé
sur une interface graphique avec des options de menu où vous allez certainement trouver l’option
compiler ou construire.
13/04/2023 18
Généralité 4. Construction d’un programme C++
c- L’édition de liens
La compilation produit un fichier objet avec l’extension
« .obj » non encore exécutable, pour le rendre exécutable,
il reste à lancer l’éditeur de liens (liens ou links).
L’éditeur de liens permet de lier plusieurs fichiers objets

résidant dans des bibliothèques différentes et de classes à
inclure dans des programmes.
13/04/2023 Les étapes du cycle de développement d’un programme C++. 19

Mon premier programme en C++ 1. Structure élémentaire d’un programme C++
Avant d’approfondir la programmation avec C++ nous allons illustrer le principe de l’écriture d’un
programme C++ à travers un exemple simple.
Observons de prêt ce petit programme qui affiche le message « Hello world! » à l’écran:
 Analysons les éléments de ce programme

#include est une directive de pré-processeur qui s’exécute
lors de la compilation, elle permet d’insérer le fichier
spécifié dans le programme. Ici on a le fichier iostream
forme abrégée de input-output-stream qui est nécessaire
à l’instruction cout.
Un namespace, ou espace de nom (parfois aussi espace

de nommage) est une zone de déclaration d'identificateurs
using namespace std est un espace de nom permettant au compilateur de résoudre les conflits de
standard, on l’ utilise pour alléger l'écriture, ce noms.
qui permet de s'affranchir de l'obligation de
préfixer par std::
13/04/2023 20
Mon premier programme en C++ 1. Structure élémentaire d’un programme C++
int main ( ) le programme principal commence avec la fonction main ( ) qui doit retourner une valeur.
Dans notre cas, elle renvoie un entier, c’est-à-dire int.
La fonction main s’exécute à chaque lancement du programme, sont contenu ce trouve entre les accolades
ouvrante et fermante
Les accolades ouvrante et fermante représentent respectivement, le début et la fin du corps du programme.
L’instruction cout<< "Hello world!" <<endl; fait parti de la fonction main et permet d’afficher le
message Hello world! à l’écran.
Remarque:
• Le message à afficher à l’écran doit être compris entre les doubles cotes "".
• Le symbole << est un opérateur de redirection pour les sortie à l’écran.
• Le endl correspondent à un saut de ligne, c’est-à-dire afficher le message et revenir à la ligne.
L’instruction return 0; permet de retourné une valeur. Dans ce cas de figure elle renvoie l’entier 0, qui est
la valeur de retour de la fonction main.
13/04/2023 21
Mon premier programme en C++ 2. Mon 1er programme dans l’IDE Code::Blocks 17.12
Avant tout lancer Code::Blocks en double cliquant sur son icone de raccourci. En suite procéder comme suit :
Cliquer sur le menu File > New > Project…
13/04/2023 22
Dans la fenêtre qui s'ouvre (fig. à gauche), choisissez « Console application » et cliquer sur le bouton
Go. La fenêtre de droite apparait sélectionner C++ et cliquer sur Next.
Sélectionner
C++
13/04/2023 23
1- Donner un nom a votre projet 4- Choisir un Compilateur
Cliquer
Donner sur
un
Choisir
nom a votre
projet
Choisir un
emplacement
2- Choisir l’emplacement où
enregistré votre projet
3- Cliquer sur Next

5- Cliquer sur Finish
13/04/2023 24
Compiler et Exécuter un programme
 Un compilateur est un programme informatique qui traduit ou transformer votre code
source écrit dans un langage évolué (C++, java…) en un code objet (langage binaire
compréhensible par l’ordinateur).
 Un débugger (« Débogueur » ou « Débugueur » en français) sert à trouver ou à traquer

les erreurs dans votre programme (on n'a malheureusement pas encore inventé le «
correcteur », un truc qui corrigerait tout seul nos erreurs).
Après avoir écrit votre programme
Compiler et Exécuter
Compiler (Build) Exécuter (Run) Annuler (Abort)
(Build and Run)
13/04/2023 25
Mon premier programme en C++ 3. Elément d’un programme C++
3.1. Les commentaires :
Un commentaire sert à faciliter la lisibilité du programme, le programmeur est guidé par ces commentaires
pour se retrouver. Un commentaire est un simple texte qui n’est pas traité par le compilateur.
Il existe deux types de commentaires en C++ :
• Le premier est symboliser par deux barres obliques (slaches) //.
Toute ligne commençant par ce symbole est considérée comme commentaire.
Exemple :
// Ceci est un commentaire qui tient sur une ligne
• Le second est représenté par le symbole « barre oblique étoile » /* et */ de façon à ce que :
/* indique le début du commentaire et
*/ indique la fin du commentaire
Le commentaire compris entre ces deux symboles peut tenir sur plusieurs lignes.
Exemple :
/* ceci est un commentaire qui peut tenir
sur plusieurs lignes */.
13/04/2023 26
3.2. Déclaration de variables :
Une variable est un emplacement mémoire destiné à recevoir des données, elle possède un nom et un type.
Le compilateur alloue à chaque variable un espace mémoire après l’avoir déterminé (selon son type).
En C++ il existe plusieurs types de variables, on distingue :
• Les variables entières qui peuvent être signées ou non signées.
• Les variables décimales (ou à virgule flottante). Le mot clé const garanti que
• Les variables caractères. la valeur de la variable ne
• Les variables booléennes. changera pas
Comment déclarer une variable en C++ ?
Pour déclarer une variable, on doit indiquer son type suivi d’un espace puis taper le nom de la
variable suivi d’un point-virgule : <type> <nom-de-la-variable> ;
Pour les constante, on ajoute le mot clé const comme suit : const <type> <nom-de-la-variable> ;
Exemple :
int somme ; //somme est une variable de type entière.
13/04/2023 const float PI = 3.14; //PI est une constante de type réel initialisé à 3.14. 27
3.2. Déclaration de variables :
Le tableau ci-dessus représente les types de variables en C++.
Type C++ Traduction française Taille
unsigned short int Entier court non signé 2 octets Rappel :
short int Entier court 2 octets 1 octet = 8 bits
unsigned long int Entier long non signé 4 octets

long int Entier long 4 octets
int Entier 2 octets
unsigned int Entier non signé 2 octets
char Un caractère 1 octet
string Chaîne de caractère 4 octets
float Nombre décimal 4 octets
double Nombre double (les très grands nombres) 8 octets
bool Variable booléenne vrai (true) ou faux (false) 1 octet
13/04/2023 28
3.3. Les instruction d’affectations et expression :
 L’affectation :
On utilise l’opération d’affectation symbolisé par = (égale) pour affecter une valeur à une
variable :
Exemple :
int somme ;
somme = 10 ; //on lit : somme reçoit la valeur de 10.
Ces deux lignes et
 Incrémentation peuvent être remplacé par : int somme = 10 ;
décrémentation :
Ces opérations consistent à ajouter ou soustraire 1 à une variable. C++ propose pour cela deux
opérateurs ++ et --.
Exemple :
i++ ; // i est égale à i+1
i++ ; i=i+1 ; ou i+=1 ; sont équivalentes.
i-- ; i=i-1 ; ou i-=1 ; sont équivalentes.
13/04/2023 29
 Préfixe et suffixe :
Un préfixe précède le nom de la variable ++i
Un suffixe suit le nom de cette variable i++
Exemple 1 :
int a=5 ;
X = ++a ;
Le résultat de cette expression est le suivant :
Le compilateur incrémente a (a = 5+1 = 6) et X = 6.
Exemple 2 :
int a=5 ;
X = a++ ;
Dans cette expression les choses sont différentes :
Le compilateur extrait la valeur de a (5), l’affecte à X, puis incrémente a, c’est-à-dire, on aura :
a = 6 et X = 5
13/04/2023 30
 Evaluation d’expressions :
Une expression est une instruction qui renvoie une valeur d’évaluation.
Exemple :
a = 10 * 2 + 3 ;
somme = a + b ;
s = somme + 1 ;
aire = PI * sqrt (rayon)

13/04/2023 31
3.4. Les opérateurs :
En programmation, un opérateur est un symbole qui ordonne au compilateur d’effectuer une opération.
Il existe plusieurs types d’opération :
• L’opérateur d’affectation: le C++ utilise l’égale = comme opérateur d’affectation
X = a + b ;
• Les opérateurs arithmétiques
Ils sont au nombre de cinq (5) l’addition (+), la soustraction (-), la multiplication (*), la division
(/) et le modulo (%).
• Les opérations relationnelles

o Il en existe six (6):
o Egal à (==), différent de (!=), supérieur à (>), supérieur ou égal à (>=), inférieur (< ) et
inférieur ou égale à (<=).
Exemple :
int a=10, b=20; //déclaration avec initialisation des variables a et b.
a==b; //cette opération donne la valeur false.
a<b; //cette opération donne la valeur true.
13/04/2023 32
• Les opérations d’Entré/Sortie standard
Les entrées et sorties sont gérées par deux classes définies dans le fichier d'en-tête <iostream> :
 ostream (output stream) permet d'écrire des données vers la console, un fichier, ... On utilise
l'opérateur << .
 istream (input stream) permet de lire des données à partir de la console, d'un fichier, ... On utilise
l'opérateur >> .
Exemple: Flux (flots) standards

cout écrit vers la sortie standard,
cerr écrit vers la sortie d'erreur,
cin lit à partir de l'entrée standard.
Ces trois objets sont définis dans l'espace de nom

std.
13/04/2023 33
Exemple:
13/04/2023 34
Retient:
L’affichage d’informations à l’écran est réalisé en envoyant des valeurs sur le « flot cout », avec un seule
cout on peut afficher plusieurs valeur à l’écran y compris des messages. Comme dans :
cout<< "VOTRE AGE EST:" <<age; // affiche le message et l’âge sur l’écran (le terminal DOS)
La lecture d’informations au clavier est réalisée en extrayant des valeurs du « flot cin », comme dans :
cin >> x >> y ; // lit deux valeurs au clavier et les affecte respectivement aux variables x et y
préalablement déclarées.
13/04/2023 35
int
return 0;
13/04/2023 36
4 Les opérateurs :
• Liste des opérateurs de C++
Nom Opérateur Exemple
Egal à == a==b
Différent de != a !=b
Supérieur à > a>b
Supérieur ou égal à >= a >= b
Inférieur < a<b
Inférieur ou égal à <= a <= b
Et logique && a && b
OU logique || a || b
Non logique ! !a
Addition + a+b
Soustraction - a–b
Multiplication * a*b
Division / a/b
Modulo (reste) % a%b
Sortie << cout << n
Entrée >> cin >> n
13/04/2023 37
Les structure de contrôle C++ 1. Les blocs d’instructions
1.1. Définition
Un bloc est une suite d’instructions placées entre { et }. Les instructions figurant dans un bloc sont
absolument quelconques. Il peut s’agir aussi bien d’instructions simples (terminées par un point-virgule)
que d’instructions structurées (choix, boucles), lesquelles peuvent alors à leur tour renfermer d’autres
blocs.
int n ;
.....
1.2. Déclaration {
// ici, on peut utiliser n
Nous avons vu qu’il était nécessaire de déclarer une }
variable avant son utilisation au sein
d’un programme. Bien entendu, toute variable déclarée Mais C++ vous autorise également à déclarer des
avant un bloc est utilisable dans ce variables à l’intérieur d’un bloc, comme
bloc : dans :
.....
{
Pour l’instant, nous n’insisterons pas plus sur cet int p ;
aspect qui sera examiné plus en détail en même temps ..... // ici, on peut utiliser p
que les variables locales à une fonction. }
..... // mais, ici, p n’est plus connu
13/04/2023 38
Les structure de contrôle C++ 2. Le traitement alternatif
 Syntaxe alternative simple : if
if (condition) Elle permet de tester une condition, si elle est
{ vérifiée, le bloc d’instruction qui suit sera exécuté.
// Séquences des instructions;
}
 Syntaxe alternative composée: if… else

if (condition)
{
// Séquences des instructions 1;
}
else
{
// Séquences des instructions 2;
}
Si la condition est vérifiée le premier bloc d’instructions s’exécute sinon c’est le deuxième bloc
qui sera exécuté.
13/04/2023 39
 Syntaxe alternative imbriquée :
Une structure if ou else peut renfermer une autre instruction if ou else, on parle d’imbrication de
condition
if (condition_1)
{
if (condition_2)
{
// Séquences des instructions 1
}
}
else
{
if (condition_3)
{
}
else
{
}
}
13/04/2023 40
 Syntaxe alternative multiple: switch
L’instruction switch permet de simplifier les choses lorsque le niveau d’imbrication des if est trop
élevé.
switch (choix) Si expression correspond à l’une des valeurs

{ de «case», le bloc d’instruction
case valeur_1:séquence 1; correspondant sera exécuté jusqu’à la
break; rencontre de l’instruction « break ».
case valeur_2:séquence 2; Sinon le programme pointe directement vers
break; l’instruction « default ».
…….
case valeur_n:séquence n;
choix: est une expression pouvant retourner
break;
une valeur.
default:séquence_par_défaut
break;
} valeur i: ce sont des valeurs à comparer avec
le choix.
13/04/2023 41
 Syntaxe alternative multiple: switch
int
Remarque:
 Si l’instruction break ne figure pas dans

un bloc d’instruction alors l’exécution du
programme se poursuit séquentiellement.
 L’instruction arrête l’exécution de

l’instruction switch.
return 0;
13/04/2023 42
Les structure de contrôle C++ 3. Le traitement répétitif (les boucles)
Le traitement est répétitif si son exécution se répète plusieurs fois, le nombre de répétitions peut être connu
ou pas, on parle de boucles ou itération.
 Syntaxe de la boucle tantque : while
Exemple : programme qui affiche les dix premiers entiers positifs.
while (condition)
{ #include<iostream>
instruction_1; using namespace std;
instruction_2;
... int main()
instruction_n; {
} int i = 0;
while (i < 10)
Principe: {
On teste la condition : cout << "La valeur de i est : " << i <<endl;
i++; // incrémentation du compteur
• si elle est vraie, on exécute les instructions
}
du bloc et on recommence. cout << "La valeur finale de i est : " << i <<endl;
• si elle est fausse, la boucle est terminée, on return 0;
passe à l'instruction suivante. }
13/04/2023 43
 Syntaxe de la boucle répété…jusqu’à : do…while
do Exemple : programme qui affiche les dix premiers entiers positifs.
{
instruction_1; #include<iostream>
instruction_2; using namespace std;
...
instruction_n; int main()
} while (condition); {
int i = 0;
do
Principe: {
1. on exécute les instructions ; cout << "La valeur de i vaut : " << i << endl;
2. on évalue la condition ; i = i + 1;
3. si elle est vraie, on recommence au 1 ; } while (i < 10);
4. si elle est fausse, la boucle se termine, on cout << "La valeur finale de i est " << i <<endl;
passe à l ’instruction suivante. return 0;
}
13/04/2023 44
 Syntaxe de la boucle pour : for
Exemple : programme qui affiche les dix fois le message
for (compteur = VI; compteur < VF; compteur++) « BONJOUR le CFI-CIRAS ».
{
instruction_1;
instruction_2; #include<iostream>
... using namespace std;
instruction_n;
} int main()
{
Principe: (VI = valeur initial et VF = vaveur finale) int i;
for (i = 0; i<10; i++)
1. On exécute l'instruction initialisation du compteur. {
cout << "BONJOUR le CFI-CIRAS" <<endl;
2. On teste la condition (comparer compteur et VF) :
}
• Tant qu'elle est vraie, on exécute les instructions de
return 0;
1 à n, on incrémente le compteur puis on revient }
au 2.
• si elle est fausse, la boucle se termine et on passe à
l'instruction suivante.
13/04/2023 45
Les structure de contrôle C++ 4. Les variantes de la boucle for
Les trois éléments (initialisation, test et action) peuvent présenter un grand nombre de variations, on
présentera ici quelque cas:
 La boucle sans paramètres :
 Initialisation et incrémentation multiples:
Exemple:
Exemple: for (int i=0, j=0; i<3; i++, j++)
{ int c = 0;
cout << i << j << endl; for ( ; ; )
} {
if (c < 3)
 Utilisation d’instructions nulles : {
cout << c <<endl;
Exemple: int c = 0; c++;
for ( ; c<3 ; ) }
{ else
c++; {
cout << c <<endl; break;
} }
}
13/04/2023 46
Les structure de contrôle C++ 4. Les variantes de la boucle for
 Boucle for vide :
Exemple:
for (int i = 0; i < 5; cout << "i:" << i++ << endl);
Cette instruction est équivalente à :
for (int i = 0; i < 5; i++)

cout << "i:" << i << endl;
13/04/2023 47
Les structure de contrôle C++ 5. Les instruction break et continue
 L’instruction break :
Nous avons déjà vu l’instruction break au sein de l’instruction « switch ».
L'instruction break sert à "casser" ou interrompre une boucle (for, while et do), ou un switch.
Exemple:
#include<iostream>
using namespace std; Ce programme interrompt sa boucle lors de
la sixième itération.
int main()
{
for (int i = 0; i < 10; i++)

{
cout << "La variable i vaut: " << i << endl;
if (i == 5)
{
break;
}
}
return 0;
}
13/04/2023 48
Les structure de contrôle C++ 5. Les instruction break et continue
 L’instruction continue :
L’instruction break saute le reste des instructions présentes dans le bloc de la boucle, en se rendant
immédiatement à l’instruction suivante en dehors de la boucle. L’instruction continue saute également le
reste des instructions dans la boucle, toutefois , au lieu de mettre fin à la boucle, elle se met au début de la
boucle et exécute l’instruction suivante
Exemple:
#include<iostream> Ce programme saute l'affichage de la
using namespace std; sixième itération (i vaut: 5)
int main()
{
for (int i = 0; i < 10; i++)
{
if (i == 5) continue;
cout << "La variable i vaut: " << i << endl;
}
return 0;
}
13/04/2023 49
Les structure de contrôle C++ 6. Remarque générale sur les boucles
 Toutes les boucles peuvent être imbriquées les unes à l’intérieur des autres.
 La boucle while peut ne pas s’exécuté du tout si la condition n’est pas vérifié.
 Le boucle do…while s’xécute au moins une fois.
 La boucle for s’exécute toujours et le nombre d’itération est connu d’avance.
 Les boucles while et do…while nécessitent toujours une initialisation et une incrémentation du
compteur de la boucle dans le cas où le nombre d’itération est connu, sinon la condition fixée doit être
possible à atteindre pour ne pas avoir une boucle infini.
Exemple : boucle infini. #include<iostream>

using namespace std;
int main()
{
int i = 0;
while (i < 10)
{
cout << "La valeur de i est : " << i <<endl;
}
cout << "La valeur finale de i est : " << i <<endl;
return 0;
}
13/04/2023 50
Exercices d’applications
Énoncé
Soit le petit programme suivant :
Écrire un programme réalisant exactement la
#include <iostream> même chose, en employant, à la place de
using namespace std ;
l’instruction for :
void main()
{
int i, n, som ; a. une instruction while,
som = 0 ;
for (i=0 ; i<4 ; i++) b. une instruction do ... while.
{
cout << "donnez un entier " ;
cin >> n ;
som += n ;
}
cout << "Somme : " << som ;
return 0;
}
13/04/2023 51
Solution:
a. b.
#include <iostream> #include <iostream>
using namespace std ; using namespace std ;
int main() int main()
{ {
int i, n, som ; int i, n, som ;
som = 0 ; som = 0 ;
i = 0 ; /* ne pas oublier cette "initialisation" */ i = 0 ; /* ne pas oublier cette "initialisation" */
while (i<4) do
{ {
cout << "donnez un entier " ; cout << "donnez un entier " ;
cin >> n ; cin >> n ;
som += n ; som += n ;
i++ ; /* ni cette "incrémentation" */ i++ ; /* ni cette "incrémentation" */
} }
cout << "Somme : " << som ; while (i<4) ; /* attention, ici, toujours <4 */
return 0; cout << "Somme : " << som ;
} return 0;
}
13/04/2023 52
Énoncé
Quels résultats fournit le programme suivant :
#include <iostream>
using namespace std ;
void main()
{
int n=0 ;
Solution:
do
{ if (n%2==0) { cout << n << " est pair\n" ; 0 est pair
n += 3 ; 3 est multiple de 3
continue ; 9 est multiple de 3
} system("pause"); 15 est multiple de 3
if (n%3==0) 20 est multiple de 5
{ cout << n << " est multiple de 3\n" ;
n += 5 ;
}
if (n%5==0)
{ cout << n << " est multiple de 5\n" ;
break ;
}
n += 1 ;
}
while (1) ;
return 0;
13/04/2023 } 53
L’ALGORITHME
Les fonctions
Semestre I
Niveau 1er Année:
Licence Informatique
DUT Informatique de gestion
DUT Maintenance informatique
Sommaire
1.Définition
2.Déclaration, définition et appel d’une fonction
2.1.Déclaration d’une fonction
Déclaration locale:
Déclaration globale:
2.2.Définition d’une fonction
2.3.Appel d’une fonction
3.Variables locales et variables globales
3.1.Variables locales
3.2.Variables globales
4.Passage de paramètres à une fonction
4.1.Utilisation de fonction comme paramètres d’autres fonctions
4.2.Les paramètres par défaut
4.3.Surcharge des fonctions
13/04/2023 55
1. Définition
Une fonction est un sous-programme destiné à accomplir une tâche bien définie.
Les fonctions permettent de répondre à deux objectifs principaux :
 Eviter les répétitions, et
 Créer des modules accomplissant chacun une tâche spécifique.
Ces deux objectifs permettent de rendre les programmes plus lisibles et plus faciles à maintenir (à corriger et à
améliorer).
Une fonction peut être alors considérer comme une boite noire, qui en partant des données (paramètres)
d’entrée, exécute des actions (Traitement) et renvoie un résultat en sortie (retour de la fonction). La fig.
suivante représente une schématiquement une fonction.
Entrée Fonction Sortie
13/04/2023 56
2. Déclaration, définition et appel d’une fonction 2.1. Déclaration d’une fonction
En C++, toute fonction utilisée doit être déclarée avant la fonction principale « int main () ». La
déclaration indique au compilateur le nom de la fonction, son type et ses paramètres (ou arguments). Elle
doit toujours se terminer par un point-virgule. Le type d’une fonction est déterminé par le type de la variable
ou de l’expression que la fonction retourne. Si la fonction ne retourne aucune valeur, elle est de type
« void ». La déclaration d’une fonction est appelée son prototype.
 Syntaxe :
<TypeRésultat> <NomFonction>(<TypePar1> <NomPar1>,...,<TypeParN> <NomParN>);
Ou : <TypeRésultat> <NomFonction>(<TypePar1>,...,<TypeParN>);
 Signification :
<TypeRésultat>: est la sortie et donc le type de retour de notre fonction.

<NomFonction> : Nom de la fonction, permet de l’identifier de façon unique.
<TypePar1> <NomPar1>,...,<TypeParN> <NomParN>: représente les entrées ou paramètres de notre
fonction.
13/04/2023 57
2. Déclaration, définition et appel d’une fonction 2.1. Déclaration d’une fonction
 Exemples :
int fonction_1 (int a, int b) ; ou int fonction_1 (int, int) ;

float fonction_2(void) ; ou float fonction_2() ;
void fonction_3(int a, char c); // La fonction fonction_3 reçoit en paramètre un entier a et un caractère c, elle ne
retourne rien, elle est donc déclarée de type « void ».
bool veriter(bool) ; // veriter est une fonction qui prend un booléen en paramètre et retourne aussi un booléen.
double Surface (double L, double l) ; // La fonction surface prend 2 arguments de type double, elle retourne un double,
elle est donc déclarée de type « double ».
 Déclaration locale:
Une fonction peut être déclarée localement dans la fonction qui l'appelle (avant la déclaration des variables). Elle est
alors disponible à cette fonction.
 Déclaration globale:
Une fonction peut être déclarée globalement au début du programme (derrière les instructions #include). Elle est
alors disponible à toutes les fonctions du programme.
13/04/2023 58
2. Déclaration, définition et appel d’une fonction 2.2. Définition d’une fonction
Définir une fonction consiste à écrire les instructions qui la composent. En général, la définition de la fonction
se fait après le programme principal « int main() ».
 Syntaxe :
<TypeRésultat> <NomFonction>(<TypePar1> <NomPar1>,...,<TypeParN> <NomParN>)

{
<déclarations locales>;
<instructions>;
}
Remarquez qu'il n'y a pas de point-virgule derrière la définition des paramètres de la fonction.
 Attention :
Si nous choisissons un nom de fonction qui existe déjà dans une bibliothèque, notre fonction va cacher la fonction
prédéfinie ou le compilateur signalera une erreur.
13/04/2023 59
2. Déclaration, définition et appel d’une fonction 2.2. Définition d’une fonction
Remarques :
 Une fonction peut fournir comme résultat:
 un type arithmétique,
 un pointeur,
 void (la fonction correspond alors à une « procédure »).
Une fonction ne peut pas fournir comme résultat des tableaux, des chaînes de caractères ou des fonctions. (Il est
cependant possible de renvoyer un pointeur sur le premier élément d'un tableau ou d'une chaîne de caractères).
• Si une fonction ne fournit pas de résultat, il faut indiquer void (vide) comme type du résultat.
• Si une fonction n'a pas de paramètres, on peut déclarer la liste des paramètres comme (void) ou simplement
comme ().
• Le type par défaut est int; autrement dit: si le type d'une fonction n'est pas déclaré explicitement, elle est
automatiquement du type int.
• Il est interdit de définir des fonctions à l'intérieur d'une autre fonction (comme en Pascal).
• En principe, l'ordre des définitions dans le texte du programme ne joue pas de rôle, mais chaque fonction doit
être déclarée ou définie avant d'être appelée.
• Enfin vous avez les accolades qui indiquent le début et la fin de la fonction. À l’intérieur de ces accolades
vous mettrez les instructions que vous voulez.
13/04/2023 60
2. Déclaration, définition et appel d’une fonction 2.3. Appel à une fonction
L’appel à une fonction se fait dans le main ( ) ou dans une autre fonction en mentionnant son nom et ses
paramètres entre parenthèses. Si la fonction ne possède pas de paramètres, les parenthèses sont vides.
Il faut différencier deux cas :
1er cas : Si la fonction est de type « void » (ne retourne rien). Dans ce cas la syntaxe de l’appel est :
<NomFonction>(<NomPar1>,...,< NomParN>);
Exemple 1: fonct_1(a,b,c) ; //Appel de la fonction fonct_1() de type « void » et ayant 3 paramètres.
Exemple 2: fonct_2() ; //Appel de la fonction fonct_2() de type « void » sans paramètres.
2éme cas : Si la fonction est d’un autre type que « void » (retourne un résultat). Dans ce cas, la syntaxe de l’appel
est : <Variable> = <NomFonction>(<NomPar1>,...,< NomParN>);
Où <Variable> est une variable de même type que la fonction appelée. Cette variable est déclarée dans le main()
ou dans la fonction appelante. Son rôle est de recevoir le résultat retourné par la fonction.
13/04/2023 61
Exemple :
NB : dans le cas où la fonction retourne un résultat, l’appel de la fonction peut se faire directement dans une
fonction cout<< .
Exemple : cout<< NomFonction(<NomPar1>,...,<NomParN>);
ou bien : cout<< NomFonction(); Le résultat retourné par la fonction est donc affiché directement.
13/04/2023 62
Exemple complet : Ecrire une fonction qui effectue le produit de deux entiers et une procédure qui compare deux entier.
13/04/2023 63
13/04/2023 64
3. Variables locales et variable globales 3.1. Variables locales
En plus de pouvoir passer les paramètres à une fonction, celle-ci peut avoir ses propres variables qui sont
déclarées lors de sa définition. Les variables déclarées dans le main() sont locales au main(), et les variables
déclarées dans une fonction sont locales à cette fonction, même si elles portent le même nom. La portée des
variables est locale à la fonction qui les contient.
Dans l’exemple précédent, les variables « prod, a, b » sont locale a la fonction principale int main( ), donc il ne
peuvent pas être utilisé par une autre fonction. Cela vas de soit pour les variable « x, y, p » de la fonction
int produit( ) et le variable « n, m » de la procédure void comparaison ( ).
Note : Les paramètres d’une fonction sont des variables locales de cette fonction. Ils sont déclarés dans
l’entête de la fonction (entre parenthèse).
13/04/2023 65
3. Variables locales et variable globales 3.1. Variables locales
Exemple:
Observation : Dans le main(), i vaut 5, alors qu’il vaut 12 dans fct(). Ce qui prouve que
ce n’est pas le même i. le compilateur alloue deux espaces mémoires différents au i
déclaré dans le main() et au i déclaré dans la procédure fct().
13/04/2023 66
3. Variables locales et variable globales 3.2. Variables globales
Une variable est dite globale, si elle est connue de toutes les fonctions qui sont compilées au sein du
même programme source. Pour qu’elle soit ainsi, il faut la déclarer avant le main().
Exemple:
Observation : La variable i est déclarée globale. Dès qu’elle subit une

modification, celle-ci apparaît dans le reste du programme. C’est la même variable
partout.
13/04/2023 67
Attention !!! : On déclare une variable globale lorsque la donnés qu’elle contient est utilisée par un ensemble
de fonctions et qu’on ne souhaite pas passer cette données comme paramètre d’une fonction à l’autre.
Toutefois, ceci peut constituer un danger, car une même donnée manipulée par plusieurs fonctions peut être
source d’erreurs difficiles à localiser.
Remarque : Les variables globales ne sont connues du compilateur que dans la partie du programme source
suivant leur déclaration. On dit que leur portée (ou encore leur espace de validité) est limitée à la partie du
programme source qui suit leur déclaration (n’oubliez pas que, pour l’instant, nous nous limitons au cas où
l’ensemble du programme est compilé en une seule fois).
13/04/2023 68
Ainsi, voyez, par exemple, ces instructions :
Les variables n et x sont accessibles aux fonctions fonct_1 et fonct_2, mais pas au programme principal. En
pratique, bien qu’il soit possible effectivement de déclarer des variables globales à n’importe quel endroit du
programme source qui soit extérieur aux fonctions, on procédera rarement ainsi. En effet, pour d’évidentes
raisons de lisibilité, on préférera regrouper les déclarations de toutes les variables globales avant le
programme source juste après les # includes.
13/04/2023 69
4. Passage de paramètres à une fonction
Les paramètres passés à une fonction peuvent être de types différents. De plus, toute expression valide en
C++ peut être passée comme paramètre à une fonction, incluant les constantes, les expressions mathématiques
et logiques, et les fonctions retournant une valeur.
Les paramètres ou arguments sont les « boîtes aux lettres » d'une fonction. Elles acceptent les données de
l'extérieur et déterminent les actions et le résultat de la fonction. Techniquement, nous pouvons résumer le rôle des
paramètres en C++ de la façon suivante:
Les paramètres d'une fonction sont simplement des variables locales qui sont initialisées par les valeurs
obtenues lors de l'appel.
13/04/2023 70
4. Passage de paramètres à une fonction 4.1. Utilisation d’une fonction comme paramètre d’autres fonction
Une fonction qui retourne une valeur peut être utilisée comme paramètre d’une autre fonction.
Exemple :
13/04/2023 71
4. Passage de paramètres à une fonction 4.1. Utilisation d’une fonction comme paramètre d’autres fonction
Attention !!! : Le mot « double » (avec d minuscule) est un mot clé. C’est pour cela que nous avons écrit la
fonction « Double » (avec un D majuscule).
À l’exécution, le programme affiche ce qui suit :

Donner une valeur entière : 5
Le double du triple de 5 = 30
Le programme appelle d’abord la fonction triple(5) qui retourne la valeur 15, et appelle ensuite la fonction
Double(15), qui retourne la valeur 30 au main( ) qui l’affiche.
13/04/2023 72
4. Passage de paramètres à une fonction 4.2. les paramètres par défaut
À l’appel de la fonction, celle-ci doit recevoir un nombre de paramètres égal au nombre de paramètres
déclarés dans son prototype. De plus, ces paramètres doivent être également être de mêmes types que ceux
déclarés. Si ces deux conditions ne sont pas respectées, le compilateur signalera des erreurs lors de la phase de
compilation du programme.
Il existe une seule exception pour laquelle le nombre de paramètres à l’appel d’une fonction peut être
inférieur au nombre de paramètres déclarés : c’est lorsqu’on donne des valeurs par défaut aux paramètres.
Exemple : double fonct_3(int x, int
y=10) ;
Cette déclaration signifie que la fonction est de type « double » et qu’elle reçoit deux entiers. Lorsqu’on
appellera cette fonction, on peut lui passer juste un entier, le second prendra automatiquement la valeur 10, par
défaut.
13/04/2023 73
N’importe quel paramètre peut avoir une valeur par défaut. Toutefois si un paramètre possède une valeur
par défaut, tous ceux déclarés après, dans l’entête de la fonction, doivent en avoir une.
Exemple de déclarations correctes :
int fonct_1(int , int, int a=7) ;
void fonct_2(char, long, int x=2, int y=15) ;
double fonct_3(char c1=’A’, char c2=’B’, int c3=10) ;
Exemple de déclarations incorrectes :

int fonct_4(int , int a=7, int ) ;
void fonct_5(char ,long, int x=2, int ) ;
double fonct_3(char c1=’A’, char c2, int ) ;
13/04/2023 74
Exemple :
13/04/2023 75
Exemple :
À l’exécution, le programme affiche:

perimetre_1 = 100
perimetre_2 = 70
perimetre_3 = 30
Pour le 1er périmètre : Longueur = 30 et largeur = 20.
Pour le 2éme périmètre : Longueur = 30 et largeur = 5 (par défaut).
Pour le 3éme périmètre : Longueur = 10 et largeur = 5 (par défaut).
13/04/2023 76
4. Passage de paramètres à une fonction 4.3. Surcharge des fonctions
 Qu’est-ce que la surcharge de fonction ?
En C++, on peut créer plusieurs fonctions avec le même nom. Ceci est appelé : surcharge des
fonctions ou polymorphisme. Les fonctions doivent différer dans la liste de leur paramètres : soit dans le
nombre de paramètres, soit dans le type d’au moins un des paramètres, ou soit tout ça à la fois.
Exemple :
int somme (int, int) ;
int somme (int, float) ;
int somme (int) ;
Dans l’exemple ci-dessus, si la fonction appelée reçoit en paramètres :

o Deux entiers : c’est la première fonction qui est exécutée.
o Un entier et un réel : c’est la deuxième fonction qui est exécutée.
o Un entier : c’est la troisième fonction qui est exécutée.
Les fonctions surchargées peuvent également avoir des types différents. La liste des paramètres doit
cependant être différente, car la déclaration de deux fonctions avec le même nom, la même liste des
paramètres et des types différents va générer une erreur de compilation.
13/04/2023 77
En d’autres termes, la surcharge de fonctions consiste à déclarer des
fonctions :
o avec le même nom,
o des types identiques ou différents, et
o une liste de paramètres obligatoirement différents.
Exemple :
int fonction(int, int) ;
void fonction(int, int), /* erreur*/
Dans cet exemple, la 2éme déclaration va générer une erreur de compilation.
13/04/2023 78
 Utilité de la surcharge de fonction
Supposant qu’on souhaite écrire une fonction qui calcule le double de la valeur entrée par l’utilisateur. On
veut être capable
int de lui passer un « int », un « long », un « float » ou un « double ». Sans la surcharge des
fonctions, on doit créer quatre fonctions avec quatre noms différents :
Double_1(int) ;
int
Double_2(long) ;
int
Double_3(float) ;
int
Par contre, avec la possibilité de la surcharge de fonctions, un seul nom de fonction
Double_4(double) ;
suffit.
13/04/2023 79
13/04/2023 80
13/04/2023 81
À l’appel de la fonction Double (), le compilateur

exécute entre les 4 fonctions ayant le même nom,
celle dont le paramètre est de même type que la
variable reçue en paramètre.
13/04/2023 82
Maintenant c’est à vous
de jouer avec le langage
C++.

3 - TP Introduction A L'algorithme

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

3 - TP Introduction A L'algorithme

Transféré par

Droits d'auteur :

Formats disponibles

TRAVAUX PRATIQUES INTRODUCTION A

Installation et prise en main de l’IDE

 Code::Blocks est un IDE (Environnement de Développement Intégré) libre et gratuit,

 Vous pouvez le télécharger sur le site http://www.codeblocks.org , choisissez la version :

 Télécharger le et installer en suivant les étapes suivantes:

Il ne vous reste plus

S’il n’y pas d’erreur

Les concepts de bases du

Mon premier programme en C++

Les structures de contrôle

En 1950, Alan Turing et Maurice V. Wilkes de l'université de Cambridge branchent un clavier à un

La programmation orienté objet (P.O.O) est un module qui vous sera

L’éditeur de liens permet de lier plusieurs fichiers objets

13/04/2023 Les étapes du cycle de développement d’un programme C++. 19

 Analysons les éléments de ce programme

Un namespace, ou espace de nom (parfois aussi espace

3- Cliquer sur Next

 Un débugger (« Débogueur » ou « Débugueur » en français) sert à trouver ou à traquer

Après avoir écrit votre programme

Comment déclarer une variable en C++ ?

short int Entier court 2 octets 1 octet = 8 bits

unsigned long int Entier long non signé 4 octets

• Les opérations relationnelles

Exemple: Flux (flots) standards

Ces trois objets sont définis dans l'espace de nom

 Syntaxe alternative composée: if… else

switch (choix) Si expression correspond à l’une des valeurs

 Si l’instruction break ne figure pas dans

 L’instruction arrête l’exécution de

Cette instruction est équivalente à :

for (int i = 0; i < 5; i++)

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

Exemple : boucle infini. #include<iostream>

Entrée Fonction Sortie

Ou : <TypeRésultat> <NomFonction>(<TypePar1>,...,<TypeParN>);

<TypeRésultat>: est la sortie et donc le type de retour de notre fonction.

int fonction_1 (int a, int b) ; ou int fonction_1 (int, int) ;

<TypeRésultat> <NomFonction>(<TypePar1> <NomPar1>,...,<TypeParN> <NomParN>)

Il faut différencier deux cas :

Exemple 1: fonct_1(a,b,c) ; //Appel de la fonction fonct_1() de type « void » et ayant 3 paramètres.

Exemple 2: fonct_2() ; //Appel de la fonction fonct_2() de type « void » sans paramètres.

Observation : La variable i est déclarée globale. Dès qu’elle subit une

Ainsi, voyez, par exemple, ces instructions :

À l’exécution, le programme affiche ce qui suit :

Exemple de déclarations incorrectes :

À l’exécution, le programme affiche:

Dans l’exemple ci-dessus, si la fonction appelée reçoit en paramètres :

Dans cet exemple, la 2éme déclaration va générer une erreur de compilation.

À l’appel de la fonction Double (), le compilateur

Vous aimerez peut-être aussi