Vous êtes sur la page 1sur 82

TRAVAUX PRATIQUES INTRODUCTION A

L’ALGORITHME

Installation et prise en main de l’IDE


Semestre : 1 Code::Blocks 17.12
Licence Informatique : 1
sous Windows
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-17.12mingw-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:

05/16/2021 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 »

05/16/2021 3
Code::Blocks 2. Installation et prise en main Code::Blocks ?
Interface d’accueille Barre
d’outils

Zone
d’édition

Exploreur de
fichiers du
projet

Zone de
notification
05/16/2021 4
Code::Blocks 2. Installation et prise en main Code::Blocks ?
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. de gauche), choisissez « Console application ».

Cliquer Sélectionner
sur Go C++

05/16/2021 5
Code::Blocks 2. Installation et prise en main Code::Blocks ?
Donner un
nom a votre
projet

Choisir un
Compilateur

Choisir un
emplacement

05/16/2021 6
Code::Blocks 2. Installation et prise en main Code::Blocks ?

Compiler et
exécuter le
programme Code::Blocks vous
offre un petit code
que vous pouvez
exécuter

Vérifier les
S’il n’y pas d’erreur notifications
vous verrez le
terminal suivant

05/16/2021 7
Code::Blocks 2. Installation et prise en main Code::Blocks ?
Fenêtre d’exécution (DOS)

Cette fenêtre s’affichera à chaque fois que vous exécuterez vos programmes.
05/16/2021 8
Code::Blocks 2. Installation et prise en main Code::Blocks ?
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

05/16/2021 9
TRAVAUX PRATIQUES INTRODUCTION A
L’ALGORITHME

Les concepts de bases du


Semestre : 1
Licence Informatique : 1 langage de programmation
 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 17.12

05/16/2021 11
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 17.12
3. Eléments d’un programme C++

Les structures de contrôles


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 instructions break et continue
6. Remarques générales sur les boucles
05/16/2021 12
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 au jeu.
05/16/2021 13
Généralité 1. Quelques repères historiques
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
charge la P.O.O Noyau
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++ .

05/16/2021 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.
05/16/2021 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

05/16/2021 16
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.

05/16/2021 17
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.

05/16/2021 Les étapes du cycle de développement d’un programme C++. 18


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

05/16/2021 19
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 ne 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.

05/16/2021 20
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…

05/16/2021 21
Mon premier programme en C++ 2. Mon 1er programme dans l’IDE Code::Blocks 17.12
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++

05/16/2021 22
Mon premier programme en C++ 2. Mon 1er programme dans l’IDE Code::Blocks 17.12
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

05/16/2021 23
Mon premier programme en C++ 2. Mon 1er programme dans l’IDE Code::Blocks 17.12
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)
05/16/2021 24
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 */.
05/16/2021 25
Mon premier programme en C++ 3. Elément d’un programme C++
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.
05/16/2021 const float PI = 3.14; //PI est une constante de type réel initialisé à 3.14. 26
Mon premier programme en C++ 3. Elément d’un programme C++
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
05/16/2021 27
Mon premier programme en C++ 3. Elément d’un programme C++
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.

05/16/2021 28
Mon premier programme en C++ 3. Elément d’un programme C++
3.3. Les instruction d’affectations et expression :
 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

05/16/2021 29
Mon premier programme en C++ 3. Elément d’un programme C++
3.3. Les instruction d’affectations et expression :
 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)
 

05/16/2021 30
Mon premier programme en C++ 3. Elément d’un programme C++
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.
05/16/2021 31
Mon premier programme en C++ 3. Elément d’un programme C++
3.4. Les opérateurs :
• 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.

05/16/2021 32
Mon premier programme en C++ 3. Elément d’un programme C++
3.4. Les opérateurs :

Exemple:

05/16/2021 33
Mon premier programme en C++ 3. Elément d’un programme C++
3.4. Les opérateurs :
• Les opérations d’Entré/Sortie standard
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.

05/16/2021 34
Mon premier programme en C++ 3. Elément d’un programme C++
3.4. Les opérateurs :
• Les opérations d’Entré/Sortie standard

int

return 0;

05/16/2021 35
Mon premier programme en C++ 3. Elément d’un programme C++
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
05/16/2021 36
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
05/16/2021 37
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é.

05/16/2021 38
Les structure de contrôle C++ 2. Le traitement alternatif
 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)
{
// Séquences des instructions 2
}
else
{
// Séquences des instructions 3
}
}

05/16/2021 39
Les structure de contrôle C++ 2. Le traitement alternatif
 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.

05/16/2021 40
Les structure de contrôle C++ 2. Le traitement alternatif
 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;

05/16/2021 41
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. }

05/16/2021 42
Les structure de contrôle C++ 3. Le traitement répétitif (les boucles)
 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;
}

05/16/2021 43
Les structure de contrôle C++ 3. Le traitement répétitif (les boucles)
 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.

05/16/2021 44
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;
} }
}

05/16/2021 45
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;

05/16/2021 46
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;
}

05/16/2021 47
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;
}

05/16/2021 48
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;
}

05/16/2021 49
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;
}
05/16/2021 50
Exercices d’applications
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;
}

05/16/2021 51
Exercices d’applications
É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;
05/16/2021 } 52
TRAVAUX PRATIQUES INTRODUCTION A
L’ALGORITHME

Semestre : 1
Les fonctions
Licence Informatique : 1
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
05/16/2021 54
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

05/16/2021 55
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.

05/16/2021 56
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.
05/16/2021 57
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.

05/16/2021 58
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.
05/16/2021 59
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.

05/16/2021 60
2. Déclaration, définition et appel d’une fonction 2.3. Appel à une fonction
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.
05/16/2021 61
2. Déclaration, définition et appel d’une fonction 2.3. Appel à une fonction
Exemple complet : Ecrire une fonction qui effectue le produit de deux entiers et une procédure qui compare deux entier.

05/16/2021 62
2. Déclaration, définition et appel d’une fonction 2.3. Appel à une fonction

05/16/2021 63
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).

05/16/2021 64
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().

05/16/2021 65
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.

05/16/2021 66
3. Variables locales et variable globales 3.2. Variables globales

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).

05/16/2021 67
3. Variables locales et variable globales 3.2. Variables globales

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.
05/16/2021 68
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.

05/16/2021 69
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 :

05/16/2021 70
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.

05/16/2021 71
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.

05/16/2021 72
4. Passage de paramètres à une fonction 4.2. les paramètres par défaut
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 ) ;

05/16/2021 73
4. Passage de paramètres à une fonction 4.2. les paramètres par défaut

Exemple :

05/16/2021 74
4. Passage de paramètres à une fonction 4.2. les paramètres par défaut

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).

05/16/2021 75
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.

05/16/2021 76
4. Passage de paramètres à une fonction 4.3. Surcharge des fonctions
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.

05/16/2021 77
4. Passage de paramètres à une fonction 4.3. Surcharge des fonctions
 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.

05/16/2021 78
4. Passage de paramètres à une fonction 4.3. Surcharge des fonctions
 Utilité de la surcharge de fonction 

05/16/2021 79
4. Passage de paramètres à une fonction 4.3. Surcharge des fonctions
 Utilité de la surcharge de fonction 

05/16/2021 80
4. Passage de paramètres à une fonction 4.3. Surcharge des fonctions
 Utilité de la surcharge de fonction 

À 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.

05/16/2021 81
Maintenant c’est à vous
de jouer avec le langage
C++.

Vous aimerez peut-être aussi