Elements D'algorithme Et Programmation Part Two

ENSEIGNEMENT SUPERIEUR ET UNIVERSITAIRE
Institut Supérieur d’Informatique et de Gestion

ISIG/GOMA
#include <iostream>
using namespace std;
int main()
{
int N = 0, i = 0, nb = 0, d = 0;
bool est_premier;
cout << "Tapez la valeur de N : ";
cin >> N;
int nbrp = 1;
for (i = 2; i<N; i++)
{
/*Ecrire un programme qui teste si i est premier*/
est_premier = true;
d = 2;
while (est_premier && d * d <= i)
if (i %d == 0)
est_premier = false;
else
d++;
if (est_premier == true)
{
nb++;
cout << "Nombre premier " << nbrp << " = " << i << endl;
nbrp++;
}
}
cout << "Le nombre de nombres premiers inf\x82rieurs ou egaux \x85

" << N << " est " << nb << endl;
return 0;
}
ELEMENTS D’ALGORITHME ET PROGRAMMATION

(2e Partie : PROGRAMMATION)
Dispensé par CT ISAMUNA NKEMBO Josué
Pour les étudiants de Première Année de Licence en Informatique

1
CHAPITRE I : INTRODUCTION AUX CONCEPTS DE

PROGRAMMATION
I.1. OBJECTIF DU COURS
A la fin de ce cours, les étudiants auront acquis des compétences pouvant leurs
permettre :
- D’assimiler les concepts liés à la programmation ;
- D’assimiler la programmation en C++ et en cerner les nuances avec celle en C ;
- D’assimiler non seulement la programmation procédurale en Langage C++, mais
aussi en comprendre les bases de la POO (Programmation Orientée Objet).
I.2. DEFINITION DES CONCEPTS CLES

I.2.1. Application
Une application est un programme que l’utilisateur exécute pour accomplir une tâche.
I.2.2. Programme
Un programme est une série d’instructions devant être traités par un ordinateur. Ainsi,
un programme crée une solution à un problème concret et commence toujours par un
algorithme (Qui est une suite d’instruction simulant une solution).
I.2.3. Programmation
La programmation est l’art d’écrire des instructions capables de répondre à un
problème quelconque qui se présente. En terme simple, c’est l’action de programmer.
I.2.4. Code
Un code est un algorithme que le programmeur traduit en langage machine.
(Normalement, le langage machine désigne les 1 et les 0). Ici, il s’agit de la traduction en
utilisant la syntaxe du langage de programmation concerné. Pour le programmeur, ce terme
fait aussi allusion à un programme qui effectue une action bien précise, et cela dans un
langage de programmation spécifique (C++, Java, C, C#, PHP, etc.).
I.2.5. Code source
Un code source est un programme écrit dans un langage de programmation de haut
niveau. Il est souvent la conséquence de la programmation en obtenant un fichier ayant une
extension précise suivant le langage de programmation utilisé (.c, .cpp, .java, .cs, etc.)
2
I.2.6. Langage de programmation

Un langage de programmation permet de mettre en application une solution
implémentée par un algorithme préalablement défini. Parmi les langages de programmation,
certains sont orientés Web, Mobile ou Desktop, ou combinant les tous à la fois.
Un langage de programmation souvent dit de haut niveau (Utilisant une écriture assez
proche du langage humain) par rapport à ceux dit de bas niveau (Utilisant une écriture proche
du langage machine ou une suite des 1 et 0 : Pour exemple, nous avons le Langage
Assembleur) utilise ce que l’on appelle une syntaxe ou grammaire du langage pour une
écriture correcte traduisant tel ou tel algorithme. Ainsi lorsque cette syntaxe n’est pas bien
utilisée ou inconnue, il est alors difficile voire impossible de pouvoir programmer dans ce
langage de programmation. Nous allons voir à titre illustratif quelques langages de
programmation (De haut niveau) qui sont aujourd’hui très répandus et très utilisés.
Le C++ est un langage de niveau intermédiaire qui possède des fonctions Orientées
Objet et qui était à l’origine fait pour améliorer le langage C : De façon simplifiée, on dirait
que le C++ est l’ajout de la partie de la POO au C avec changement de la syntaxe et
simplification ou amélioration des certains concepts, ainsi celui qui connait le C++ ne peut
pas avoir des difficultés en C. Le C++ est le moteur de nombreux programmes très connus
comme Firefox (Qui utilise actuellement son langage de programmation Rust), Winamp ou
encore ceux de la suite Adobe. Il est utilisé pour développer des applications, des Systèmes
d’Exploitation (Windows XP, Cisco Internetwork Operating System ou Cisco IOS, etc.), des
serveurs et clients internet très performants ou encore des jeux vidéo. Nous allons, en effet,
nous focaliser sur ce langage de programmation dans cette partie du cours.
I.2.7. Compilateur et interpréteur

Lorsque nous écrivons un programme qui fait par exemple la somme des deux nombres
A et B, il est évident que nous devons renseigner ces deux nombres et leurs liés par un signe
pour que l’opération d’addition ait lieu. Cela signifie que l’on ferait par exemple ceci
Résultat = 8 + 2, qui donnerai que Résultat = 10 après calcul. Etant humain, nous
appréhendons ceci de façon écrite, mais qu’en est – il d’un ordinateur ? L’ordinateur ne sait
interpréter qu’une suite binaire, c’est – à – dire une série des uns et des zéros
(101110110001111101010010…), cela signifie que l’expression écrite précédemment devrait
être convertie en binaire pour que l’ordinateur soit en mesure de pouvoir la comprendre :
C’est alors qu’interviennent les opérations qui sont la compilation et l’interprétation.
3
La compilation consiste à traduire globalement l’ensemble du programme dit en

langage évolué (Appelé programme source ou code source) en langage machine (Appelé
programme objet), en utilisant un traducteur nommé compilateur. Si cette traduction s’est
déroulée sans erreur, le programme objet peut être exécuté, en le plaçant en mémoire, autant
de fois qu’on le désire, sans avoir besoin de recourir à nouveau au compilateur. D’où, en
somme, un compilateur est un élément qui traduit les instructions d’un langage de
programmation donné en code machine ou langage machine (Des 1 et des 0).
L’interprétation consiste à traduire chaque instruction du programme source, avant de
l’exécuter, à l’aide d’un traducteur nommé interpréteur. Dans ce cas, il n’existe plus de
programme objet complet. C’est le cas du HTML qui est un langage interprété car chaque
ligne de code est traduite avant d’être exécutée. D’où, en somme, un interpréteur est un
élément qui traduit chaque ligne instruction d’un langage de programmation donné en code
machine ou langage machine (Des 1 et des 0).
Ces deux procédés catégorisent les Langage de programmation avec compilateur
(C++, Java, Android, etc.) et ceux avec interpréteur (Html, Visual Basic 6.0, etc.).
I.3. INTRODUCTION AU LANGAGE DE PROGRAMMATION C++

I.3.1. Parlons C++
Avant tout, le C++ est un peu équivalent au C + la Programmation Orienté Objet, ce
qui signifie que le C++ possède tous les atouts du C et à cela s’ajoutent la Programmation
Orientée Objet. Le C++ est un langage de programmation avec compilateur car avant
exécution, le code source est premièrement compilé. Ce processus se passe de la façon
suivante : Algorithme => Code source (Programme écrit avec la syntaxe de C++ : obtention
d’un fichier .cpp) => Compilation du code source (Programme objet : Obtention d’un
fichier .obj) => Conversion du programme en langage machine (Programme exécutable :
Obtention d’un fichier .exe). A ce niveau, le fichier exécutable peut être exécuté sur n’importe
quel ordinateur car il est à ce moment indépendant du compilateur lui – même. Dans le
diagramme suivant, nous considérons que le programme source (Nom du fichier du code
source) s’appelle prog (prog.cpp).
4
Code Source Fichier Objet

(Programme en Compilateur C++ (Programme
C++) prog.cpp Objet) prog.obj
Compilation du
programme source Lien (Liaison)
Librairies C++
Fichier Exécutable
(Programme
Exécutable) prog.exe
Figure 1 : Processus d’exécution d’un programme C++

Avantages de C++
- Il est très répandu et il fait partie des langages de programmation les plus utilisés sur la
planète ;
- Il est performant et rapide (Jeux vidéo par exemple) ;
- Il est portable : Un même code source peut être transformé en exécutable sous Windows,
Mac OS et Linux ;
- Il est Orienté Objet.
Inconvénients de C++
- Il est complexe.
I.3.2. Avec quoi développer en C++

Pour pouvoir taper des lignes de code en C++ et les exécuter, il faut en effet posséder un
programme habilité pour cette fin. Il est en effet bien simple de se servir d’un éditeur de texte
comme Notepad ou le Bloc note mais nous n’aurons en aucun cas la possibilité d’exécuter
notre programme. C’est la raison pour laquelle, des éditeurs plus évolués appelé IDE
(Integrated Developement Environnement ou Environnement de Développement
Intégré) sont utilisés à la place et peuvent non seulement permettre la saisie des lignes de
code en C/C++ mais aussi faciliter leur exécution après compilation. Il en existe plusieurs et
chacun peut choisir tel ou tel IDE suivant un goût de choix ou de convivialité par exemple. En
somme, un IDE (Pour lesquels la plupart donnent la possibilité d’utiliser des interfaces
graphiques en C++) est un éditeur de texte qui incorpore plusieurs outils utiles à la
programmation (Compilation, Correction des erreurs, etc.) dans un mode Mono ou Multi-
langage de programmation. Nous en citons quelques uns :
- Microsoft Visual C++ (https://visualstudio.microsoft.com/) ;
5
- CodeBlocks (https://www.codeblocks.org/downloads) : Notre choix pour le cours ;

- NetBeans (https://netbeans.org) ;
- Eclipse (https://www.eclipse.org/downloads/) ;
- Qt (https://www.qt.io/download) ;
- Dev C++ (https://bloodshed.net, https://sourceforge.net/projects/orwelldevcpp/) ;
- Etc.
Il est à noter que quel que soit l’outil de développement que chacun peut utiliser, le
principe de base reste le même et l’extension des fichiers source est .cpp en C++. Ainsi,
nous pouvons avoir des fichiers comme bonjour.cpp, monexercice.cpp, main.cpp, etc.
Code ou programme
écrit en C ou C++
Compilation et lien
Non
Réussi ?
Oui
Exécution et test du
programme
Oui Erreur Non

Effectué !
logique ?
Figure 2 : Processus de débogage d’un programme C++
I.3.3. Règle à respecter pour bien programmer en C++

Voici quelques règles utiles pour bien programmer en C++ :
6
1. Importation de la bibliothèque standard d’entrée – sortie grâce à l’instruction

suivante : #include<iostream>. Exécuter (Avec i : Input, o : Output et stream :
Flux) Flux d’entrée – sortie.
2. Faire appel à l’espace des noms standard par l’instruction :
using namespace std; Les namespaces ou espaces de noms nous permettent de
regrouper des entités nommées qui auraient autrement une portée globale dans des
étendues plus étroites ;
3. Chaque instruction doit obligatoirement se terminer par un séparateur qui est le
point-virgule : ;
4. Chaque programme doit posséder une méthode (Fonction) principale d’entrée du
programme qui s’appelle main : int main(){ }
5. Pour afficher quelque chose, on utilise l’instruction suivante :
cout<<"Contenu pour affichage";
6. Pour récupérer une saisie au clavier, on utilise l’instruction suivante :
cin>>nom_variable;
7. Ne jamais déclarer une variable qu’on ne va pas utiliser.
8. Pour le retour à la ligne, utiliser l’instruction cout<<endl; ou cout<<"\n";
9. Pour utiliser des caractères spéciaux (Comme é, è, etc.), recourir aux caractères
Unicode ou ASCII tout en utilisant leur représentation hexadécimale comme ceci :
cout<<"Voici une b\x88te"; qui affichera Voici une bête.
7
CHAPITRE II : LES VARIABLES

II.1. DEFINITION
Une variable est une réservation d’un espace en mémoire pour un but bien précis. Il
peut par exemple servir à stocker un nombre pour effectuer une addition avec une autre qui
sera aussi stockée.
Cette notion, simple en apparence, contribue considérablement à faciliter la réalisation
des programmes, car elle fait intervenir le stockage des données. Elle vous permet, en effet, de
manipuler des valeurs sans avoir à vous préoccuper de l’emplacement qu’elles occuperont
effectivement en mémoire. Pour cela, il vous suffit de leur choisir un nom (Ou plus
précisément une étiquette qui sera collée à la variable en mémoire centrale).
II.2. LES NOMS DES VARIABLES
Pour pouvoir différencier une variable d’une autre, il est indispensable de leurs attribuer
des noms et ces derniers ne doivent pas être identique afin d’éviter toute ambigüité. Cette
nomenclature pour être valide doit respecter quelques règles :
- Les noms de variables sont constitués des lettres, des chiffres et du tiret-bas _
uniquement (Underscore) ;
- Le premier caractère doit obligatoirement être une lettre (Majuscule ou minuscule) :
Ces deux langages (C et C++) sont sensibles à la casse : Cela signifie que Majuscule
est différente de Minuscule. Exemple : Variable est différent de variable ;
- On ne peut pas utiliser d'accents ou des caractères spéciaux ;
- On ne peut pas utiliser d'espaces dans le nom.
Exemple 1 : Nom des variables
A, a, nombre_premier, designationEcole, NombreEleve, Age_enfant, numero_telephone,
Isig2, g1ig, etc.
Exemple 2 : Mon premier programme en C++

Le programme suivant permet tout simplement d’afficher Bonjour le monde.
#include<iostream>
int main(){
cout<< "Bonjour le monde";
return 0;
}
8
II.3. LES TYPES DES VARIABLES

Les variables ne contiennent pas nécessairement le même contenu. C’est le cas par
exemple d’un nombre entier (10, 11, etc.), d’un nombre décimal (2.6 ; 0.3 ; 3.142857 ; etc.),
d’une lettre de l’alphabet (g, t, s, H, etc.), d’une chaîne des caractères (le 17 janvier
2002, l’auditoire des Informaticiens, Toute la ville, etc.) ou autre chose (Variable
Object). Cette notion de diversité d’éléments à stocker fait ainsi intervenir ce que l’on appelle
un type de variable. Chaque type des variables renseigne sur une taille en octet occupée dans
la mémoire. Le tableau ci - dessous donne une illustration plus concrète pour les variables
dites de type de base (Les plus utilisés et qui existes dans presque tous les langages de
programmation) et ceux objets (Utilisés dans la Programmation Orientée Objet.
Taille
Type Exemple de contenu
(Octet)
A. Types de base
bool (Booléen) 1 True ou False. Ex : bool ok = false;
char (Caractère) 1 Caractère. Ex : char mon_caractere = 'K';
short (Petit nombre entier) 2 Nombre entier compris entre -32 768 et 32 767. Ex : short nbr = 12;
Nombre entier compris entre -2 147 483 648 à 2 147 483 647.
long (Grand Nombre entier) 4
Ex : long nbr1 = 2458948963;
int (Varie par installation

16Bits, 32Bits ou 64Bits et
4 Ex : int nbr2 = 12;
respectivement à 216, 232, ou
264 en valeur maximale)
Nombre réel : +/- 3.4e+/- 38 (~7 digits). Ex : float nbr3 =

float (Petit nombre réel) 4
3.142857;
Nombre réel en double précision : +/- 1.7e +/- 308 (~15 digits).
double (Grand nombre réel) 8
Ex : double nbr4 = 24e69;
B. Autres types
Correspond à double mais avec une précision un peu plus poussée (~18
long double (Grand Nombre
12 digits).
décimal)
Ex : long double nbr5 = 39e209;
9
Permet de représenter des chaînes des caractères.

string (Chaîne des caractères) 4
Ex : string nom_eleve = "INGABIRE Alphonse";
Ce type intervient dans la Programmation Orientée Objet et objet prend

une valeur suivant la classe donnée.
objet Ex : Si nous avons une classe Personne, nous pouvons déclarer un
objet de type Personne en écrivant : Personne p; et on peut évoquer
une méthode de cette classe en faisant p.afficherNomPersonne();
Il faut savoir qu’une bonne utilisation des variables conduit à une optimisation de la
mémoire (RAM) de l’ordinateur de sorte à lui permettre de pouvoir effectuer d’autres
traitements. Il est évident que cet état des choses ne peut se remarquer lorsque l’on manipule
des petits programmes (Addition des deux nombres, calcul du produit des trois nombres, etc.),
mais lorsque l’on doit faire un programme complexe avec beaucoup des fonctionnalités, cet
aspect est très capital.
Il est possible de pouvoir connaître la taille occupée en mémoire par un type quelconque
en utilisant le mot clef sizeof (En minuscule).
Exemple 3 : Utilisation de l’instruction sizeof
#include<iostream>
int main(){
cout<< "Taille de bool : " << sizeof(bool) << endl;
cout<< "Taille de char : " << sizeof(char) << endl;
cout<< "Taille de short : " << sizeof(short) << endl;
cout<< "Taille de long : " << sizeof(long) << endl;
cout<< "Taille de int : " << sizeof(int) << endl;
cout<< "Taille de float : " << sizeof(float) << endl;
cout<< "Taille de long double : " << sizeof(long double) << endl;
cout<< "Taille de double : " << sizeof(double) << endl;
cout<< "Taille de string : " << sizeof(string) << endl;
return 0;
}
10
II.4. NOTATION DES VALEURS
II.4.1. Valeurs entières

Les entiers se notent de la manière suivante :
- Base 10 (Décimale) : Avec les chiffres de 0 à 9, et les signes ’+’ (facultatif) et ’-’.
Exemple 4 : Représentation valeurs décimales
12354, -2564
- Base 16 (Hexadécimale) : Avec les chiffres 0 à 9 et A à F ou a à f (A=a=10, B=b=11,

C=c=12, D=d=13, E=e=14 et F=f=15). Les entiers notés en hexadécimal doivent toujours
être précédés de « 0x » (qui indique la base). On ne peut pas utiliser le signe ’-’ avec
les nombres hexadécimaux. Les adresses mémoire sont généralement représentés en
Hexadécimal.
Exemple 5 : Représentation valeurs Hexadécimales
0x1AE.
- Base 8 (Octale) : Avec les chiffres de 0 à 7. Les nombres octaux doivent être précédés
d’un 0 (qui indique la base). Le signe ’-’ ne peut pas être utilisé.
Exemple 6 : Représentation valeurs Octales
01, 0154
II.4.2. Valeurs flottantes

Les flottants s’écrivent sous la forme : [signe] chiffres [.[chiffres]][e|E [signe]
exposant][f] où signe indique le signe. On emploie les signes ’+’ (facultatif) et ’-’ aussi bien
pour la mantisse que pour l’exposant. ’e’ ou ’E’ permet de donner l’exposant du nombre
flottant. L’exposant est facultatif. Si on ne donne pas d’exposant, on doit donner des chiffres
derrière la virgule avec un point et ces chiffres. Le suffixe ’f’ permet de préciser si le nombre
est de type float ou non (auquel cas il s’agit d’un double). Si on ne met ni le point, ni la
mantisse, le nombre est un entier décimal.
Exemple 7 : Représentation valeurs Flottantes
123.56.f, 12e-12, 2 « 2 » est entier, « 2.f » est réel.
II.4.3. Valeurs des caractères

Les caractères se notent entre les signes ′ et ′ (Entre simple cote quotte comme on le dit).
11
Exemple 8 : Représentation des caractères

'A', 'c', '('.
On peut donner un caractère non accessible au clavier en donnant son code en octal,
précédé du caractère '\'. Par exemple, le caractère 'A' peut aussi se noter '\101' (Ex : cout<<
endl << "J'affiche la valeur de A en utilisant l'octal = " << "\101";). Cette
notation est semblable à la celle des nombres entiers en octal, et que le ′0′ initial est
simplement remplacé par un ′\′. Il est aussi possible de noter les caractères avec leur code en
hexadécimal, à l′aide de la notation « \xNN » (Ex : cout<< endl << "J'affiche un
caractere special en utilisant l’hexadecimal : " << "\x25";), où NN est le code
hexadécimal du caractère. Enfin, il existe des séquences d′échappement particulières qui
permettent de coder certains caractères spéciaux plus facilement. Les principales séquences
d’échappement sont les suivantes :
cout<< "\a";// Bip sonore

cout<< "\b";// Backspace
cout<< "\f";// Début de page suivante
cout<< "\n";// Passage à la ligne suivante ou saut de ligne
cout<< "\t";// Tabulation
cout<< "\\";// Le caractère '\'
cout<< "\"";// Le caractère '"'
II.5. LES OPERATEURS

En C++, il existe plusieurs opérateurs qui permettent d’effectuer plusieurs opérations
(Mathématique, d’incrémentation ou logique), pour lesquels les principaux sont les suivants :
Opérateur arithmétique, opérateurs de comparaisons, opérateurs logiques, opérateur
d’incrémentation/Décrémentation et opérateur d’affectation.
N° Opérateur Signification Utilité globale
A. Opérateurs arithmétiques
01 + Addition
02 - Soustraction ou changement de signe d’une grandeur arithmétique
03 * Multiplication Permettent d’effectuer des

opérations arithmétiques
04 / Division relevant de l’arithmétique.
05 ^ Exposant
06 % Modulo. Le reste de la division d’un nombre avec un autre.

12
Comme 5%2 = 1, car c’est le reste entier que l’on obtient après
division de 5 par 2.
B. Opérateurs de comparaison
07 < Strictement inférieur à

Comparent les valeurs de
08 <= Inférieur ou égal à deux grandeurs. S’utilisent
09 > Strictement supérieur à très souvent pour évaluer des
conditions.
10 >= Supérieur ou égal à
C. Opérateurs logiques
11 && ET logique
12 || OU logique
13 & ET Binaire Permettent d’effectuer des

14 | OU Binaire opérations logiques et
s’appliquent facilement à des
15 ! Négation logique expressions booléennes
16 ~ Négation binaire (Vraie ou fausse).
17 == Egalité logique
18 != Différence logique
D. Opérateurs d’affectation
19 = Affectation valeur
20 += Ajout et affectation valeur

Permettent l’affectation des
21 -= Soustraction et affectation valeur variables par des valeurs tout
22 *= Multiplication et affectation valeur en exécutant des opérations
(Addition par exemple).
23 /= Division et affectation valeur
24 %= Modulo et affectation valeur
E. Opérateurs d’incrémentation / Décrémentation
25 ++ Incrémentation Permettent l’augmentation

ou la diminution d’une
26 -- Décrémentation valeur.
F. Autres opérateurs
27 () Fonction, Méthodes et Conditions Utilisés pour des besoins

13
28 {} Délimiteur de bloc d’instruction divers et variés.
29 [] Accès aux tableaux
Opérateur conditionnel : Evalue une condition en spécifiant quelle

30 ?: est la valeur à considérer au cas où la condition est vraie et au cas
où elle est fausse. Le tout en une seule instruction.
31 -> Accès aux membres d’une classe
32 . Accès aux membres d’une classe ou d’une structure
33 : Mise au point de l’héritage
Opérateur de portée. Permet particulièrement d’avoir accès à des

34 :: éléments se trouvant dans des namespaces différents ou dans des
classes différentes.
II.5.7. Utilisation des commentaires

Tous les langages de programmation sans exception permettent d’utiliser les
commentaires car ils rendent le code plus compréhensible par une tierce personne qui ne l’a
pas écrit. En C++, on en distingue deux : Sur une ligne (Uniligne) et sur plusieurs lignes
(Multilignes).
o Commentaires sur une ligne : //
o Commentaires sur plusieurs lignes : /* */
Exemple 9 : Représentation des commentaires
#include<iostream>
int main(){
cout<< "Bonjour le monde";
//Ceci est un commentaire sur une ligne
/*
Ceci est commentaire
sur plusieurs lignes
*/
return 0;
}
II.6. DECLARATION DES VARIABLES

Pour déclarer une variable (Ce qui a déjà été fait un peu plus haut), nous utilisons le
format suivant : Type_de_variable nom_de_variable; Si la variable doit être initialisé on
ferait ceci Type_de_variable nom_de_variable = Valeur; (Valeur peut ainsi être de
14
n’importe quel type que nous avons vu précédemment). L’initialisation d’une variable porte
le nom d’affectation d’une valeur à la variable. Ainsi lorsque l’on affecte une valeur à une
variable, on lui donne une valeur.
Exemple 10 : Affectation des variables
#include<iostream>
int main(){
int entier = 2147483647;
long double ld = -1.7e30;
float monNombre = 2.e21;
char caractere = 't';
short nbr = 12;
long nbr2 = 214748364;
float nbr3 = 3.142857;
int nombre_premier;
double nbrDouble = 24e69;
string nom_famille = "Jean de Dieu Bokanga";
return 0;
}
L’affectation d’une variable s’effectue principalement par l’utilisation du signe '=' ou du
signe égale. Lorsque dans une affectation intervient des opérateurs, on parle à ce moment
d’expression. Les opérateurs sont des signes qui permettent d’effectuer au moins une
opération voulue.
Exemple 11 : Utilisation de l’incrémentation/Décrémentation
#include<iostream>
int main(){
int compteur = 10;
cout<<"La valeur de compteur est egale a :"<<compteur<<endl;//Affiche 10
cout<<"La valeur de compteur est egale a :"<<compteur++<<endl;//Affiche 10
cout<<"La valeur de compteur est egale a :"<<++compteur<<endl;//Affiche 12
cout<<"La valeur de compteur est egale a :"<<compteur++<<endl;//Affiche 12
cout<<"La valeur de compteur est egale a: "<<compteur--<<endl;//Affiche 13
cout<<"La valeur de compteur est egale a :"<<--compteur<<endl;//Affiche 11
return 0;
}
15
II.7. EXERCICES D’APPLICATION DU CHAPITRE 2

Ex1. Ecrire un programme qui demande à l'utilisateur de taper la largeur et la longueur d'un
champ et qui en affiche le périmètre et la surface.
Ex2. Ecrire un programme qui demande à l’utilisateur de saisir 2 entiers A et B, qui échange le
contenu des variables A et B puis qui affiche A et B.
Ex3. Ecrire un programme qui permet de calculer le volume d’un cylindre après avoir
spécifier son rayon et sa hauteur sachant la formule V = π.r 2 .h .
Ex4. Ecrire un programme qui permet de convertir la température de degré Celsius en degré
Fahrenheit sachant la formule °F = (°C*1.8) + 32.
Ex5. Ecrire un programme qui permet de calculer l’hypoténuse d’un rectangle après avoir
spécifier la valeur des deux côtés de l’angle droit.
Ex6. Ecrire un programme qui affiche le cube d’un carré dont le côté sera saisi par
l’utilisateur au clavier.
Ex7. Faire un programme qui calcule le carré de deux nombres entrés au clavier.
Ex8. Ecrire un programme qui permet de faire la somme entre deux nombres entrés au
clavier.
16
CHAPITRE III : LES STRUCTURES DE CONTROLE I : LES

CONDITIONS
Pour qu’un programme soit capable de prendre des décisions, les développeurs se
servent des conditions qui permettent d’effectuer des choix sélectifs. On parle ainsi des
structures de contrôle : Parmi ceux – ci, on distingue les conditions et les boucles (Qui seront
vus au chapitre suivant).
III.1. INTRODUCTION
Les conditions permettent d’effectuer des choix suivant un ou plusieurs critères
spécifiés et évalués par un résultat booléen de forme Vrai (Condition vérifiée) ou Faux
(Condition non vérifiée). C’est ainsi qu’ils sont considérés comme des booléens car elles
évaluent des choix basés sur des expressions vraies ou fausses. Le mot clé par excellence
utilisé dans une condition est if, qui peut ne pas être suivi d’un else if ou d’un else. Voici
les principaux symboles utilisés pour évaluer les conditions :
Symbole Signification
== Est égale à
< Est inférieur à
> Est supérieur à
<= Est inférieur ou égal à
>= Est Supérieur ou égal à
!= Est différent de
! Négation (Not)
III.2. TYPE DES CONDITIONS
On distingue trois types des conditions en C++ (Condition Simples, conditions
Alternatives et conditions Imbriquées.
III.2.1. Syntaxe générale d’une condition

Une condition est introduite par l’instruction if. C’est ainsi que le programme ci –
dessous l’illustre. En outre, ce petit programme illustre aussi l’utilisation des conditions
simples.
17
Exemple 12 : Représentation condition
#include<iostream>
int main(){
if (condition) {
//Instructions
}
//Bloc d’instruction facultatif
else {
//Instructions facultatives
}
return 0;
}
III.2.2. Les conditions simples

Comme dit ci – haut, sa forme générale est semblable à celle du programme du
précédent. Ainsi, nous allons l’illustré ici par un exemple concret.
Exemple 13 : Conditions simples1
Ecrire un programme en C++ qui affiche "Tu as un téléphone IPhone 4S" si et seulement
si vous avez réussi.
#include<iostream>
int main(){
bool reussite = false;
if (!reussite) {
cout<< "Tu as un t\x82l\x82phone IPhone 4S:" << endl;
}
return 0;
}
Exemple 14 : Conditions simples2

Ecrire un programme en C++ qui affiche si un nombre est pair ou impair. Le nombre sera
saisi au clavier par l’utilisateur.
18
#include<iostream>
int main(){
int nombre = 0;
cout<< "Saisi un nombre : ";
cin >> nombre;
if (nombre % 2 == 0) {
cout<< "Le nombre " << nombre << " est pair" << endl;
}
else {
cout<< "Le nombre " << nombre << " est impair" << endl;
}
return 0;
}
Exemple 15 : Utilisation Conditions simples3 (Avec instruction conditionnelle ou ternaire)

Le programme précédent peut être fait en utilisant une condition ternaire.
#include<iostream>
int main(){
int nombre = 0;
cout<< "Saisi un nombre : ";
cin >> nombre;
(nombre % 2 == 0) ? cout<< "Le nombre " << nombre << " est pair" << endl :
cout<< "Le nombre " << nombre << " est impair" << endl;
return 0;
}
III.2.3. Les conditions alternatives

Les conditions alternatives font intervenir la notion d’alternance ou de choix exclusif
(Soit c’est l’un ou soit c’est l’autre). Ainsi, avec ces types des conditions, on a la possibilité
de tester une succession des conditions. Voici la syntaxe générale de ces genres des
conditions :
19
Exemple 16 : Syntaxe générale des conditions alternatives
#include<iostream>
int main(){
if (choix1) {
//Instructions si choix1 vrai
}
else if (choix2) {
//Instructions si choix 2 vrai
}
else if (choix3) {
//Instructions si choix 3 vrai
}
….
else if (choixN) {
//Instructions si choix N vrai
}
return 0;
}
Exemple 17 : Conditions alternative1

Ecrire un programme en C++ qui affiche "C’est le Nord" si l’utilisateur a saisi la lettre 'N'
ou 'n', qui affiche "C’est le Sud" si l’utilisateur a saisi la lettre 'S' ou 's', qui affiche
"C’est l’Ouest" si l’utilisateur a saisi la lettre 'O' ou 'o', qui affiche "C’est l’Est" si
l’utilisateur a saisi la lettre 'E' ou 'e' ; et dans le cas contraire affiche "Echec de choix".
#include<iostream>
int main(){
char choix = ' ';
cout<< "Entrez votre choix : ";
cin >> choix;
if (choix == 'N' || choix == 'n') {
cout<< "C'est le Nord";
} else if (choix == 'S' || choix == 's') {
cout<< "C'est le Sud";
} else if (choix == 'E' || choix == 'e') {
cout<< "C'est l'Est";
} else if (choix == 'O' || choix == 'o') {
cout<< "C'est l'Ouest";
} else
cout<< "Echec de choix";
return 0;
}
20
A chaque fois que l’on utilise plusieurs else if qui se suivent et qui évaluent la même
variable, il est préférable d’utiliser la clause switch...case. Ainsi, nous allons reprendre le
programme précédent mais en utilisant désormais la nouvelle clause.
Ce qu’il faut retenir est que, le switch... évalue une seule et même variable pour
différent cas (case) qui seront vérifiés, et ne considère que le cas où la condition évaluée est
vraie. Pour séparer les différents cas, on utilise le mot clé break. Enfin, si aucun des cas ne
renvoie une valeur vraie, la clause ira directement chercher les instructions situées dans
default et vas les exécuter (Néanmoins si vous l’avez placé dans la clause switch...case).
Exemple 18 : Conditions alternative2 : Switch…Case

Ici, nous allons exploiter le même programme que précédemment, tout en remplaçant les else
if par le switch...case.
#include<iostream>
int main(){
char choix = ' ';
cout<< "Entrez votre choix : ";
cin >> choix;
switch (choix) {
case 'N':
case 'n': {
cout<< "C'est le Nord";
break;
}
21
case 'S':
case 's': {
cout<< "C'est le Sud";
break;
}
case 'E':
case 'e': {
cout<< "C'est l'Est";
break;
}
case 'O':
case 'o': {
cout<< "C'est l'Ouest";
break;
} default: {
cout<< "Echec de choix";
}
}
return 0;
}
III.2.4. Les conditions imbriquées

Les conditions imbriquées comme le mot le dit (Brique) sont des conditions
entrecroisées dans d’autres : Donc des conditions dans d’autres conditions. Voici la syntaxe
générale de ces genres des conditions :
Exemple 19 : Syntaxe générale des conditions imbriquées
#include<iostream>
int main(){
if (choix) {
//Vérification autre condition
if (autre_choix) {
//Instructions pour autre condition
…..
}
}
return 0;
}
Exemple 20 : Conditions imbriquées

Ecrire un programme en C++ qui permet d’afficher "Je peux commencer mon TFC", si et
seulement si vous avez obtenu plus de 50% comme pourcentage et que le nombre d’échec aux
cours est inférieur ou égal à deux. La valeur du pourcentage obtenu sera saisie par l’utilisateur
22
au clavier, de même que le nombre d’échec aux cours. Avant de saisir le nombre d’échec, on
devra absolument vérifier que le pourcentage et supérieur à 50. Pour tout échec ou
pourcentage inférieur à 50, on affichera "DESOLE" et on ne demandera pas le nombre d’échec
aux cours ; car, on considère que l’étudiant a échoué.
#include<iostream>
int main(){
int pourcentage = 0, echec = 0;
cout<< "Entrez votre pourcentage : ";
cin >> pourcentage;
if (pourcentage > 50) {
cout<< "Entrez le nombre d'echecs : ";
cin >> echec;
cout<< endl;
if (echec <= 2) {
cout<< "Je peux commencer mon TFC" << endl;
}
} else {
cout<< "DESOLE";
}
return 0;
}
III.3. EXERCICES D’APPLICATION DU CHAPITRE 3

Ex9. Ecrire un programme qui permet d’afficher "Vous êtes un bébé" si l’âge saisi est
strictement inférieur à 5 ans, qui affiche "Vous êtes un enfant" si l’âge saisi est compris
entre 5 et 11 ans, qui affiche "Vous êtes un adolescent" si l’âge saisi est entre 12 et 17
ans et enfin qui affiche "Vous êtes adulte" si l’âge saisi est entre 18 et 100 ans. Dans le
cas contraire elle affichera "Votre saisie est invalide !!!".
Ex10. Ecrire un programme qui permet de saisir trois notes de cours pour trois étudiants
différents et qui en affiche la plus grande des trois étudiants.
23
Ex11. Ecrire un programme qui permet de simuler le fonctionnement d’une calculatrice, tout
en sachant que vous devez commencer par saisir le premier nombre, puis le second et enfin le
signe. Le signe peut être '+' pour l’addition, '-' pour la soustraction, '*' pour la
multiplication et enfin '/' pour la division. En cas de division par zéro, un message d’erreur
s’affichera en disant "La division par zéro est impossible". Après chaque opération, le
résultat sera affiché à l’utilisateur.
Ex12. Ecrire un programme qui permet de saisir un nombre entier au clavier, et qui affiche
"Le nombre est positif" si le nombre est supérieur à zéro ; et qui affiche "Le nombre
est négatif" si le nombre est inférieur à zéro.

Ex13. Ecrire un programme qui permet d’afficher un message suivant la température de l’eau
que l’utilisateur aura saisi au clavier. Si cette température est comprise entre 1°C et 30°C, le
programme affichera "L’eau est froide" ; si la température est de 0°C, le programme
affichera "L’eau est glacée" ; si la température est de 100°C, le programme affichera
"L’eau est bouillante" ; si la température est comprise entre 31°C et 99°C, le programme
affichera "L’eau est chaude". Enfin, pour toute température ne respectant aucune de celles
qui sont spécifiées ici – haut, le programme affichera "Température non autorisée".
24
CHAPITRE IV : LES STRUCTURES DE CONTROLE II : LES

BOUCLES
IV.1. INTRODUCTION
Les boucles permettent d’effectuer des traitements répétitifs aussi longtemps que le
critère conditionnel est (ou n’est pas) vraie. Ainsi suivant la vérification d’un critère donné, la
boucle peut tourner soit n fois (n étant de valeur entière) ou indéfiniment jusqu’à l’arrêter
du programme. Tous les programmes antivirus fonctionnent suivant ce principe. Une fois
installé sur votre ordinateur (Machine), il est toujours en activité en une boucle infinie tout en
vérifiant la présence d’une nouvelle menace (Thread) ; une fois que cette dernière est
détectée, elle vous affiche une notification.
Nous distinguons particulièrement trois types des boucles, à savoir :
- La boucle while ;
- La boucle do...while ;
- La boucle for.
Ces différents types de boucles peuvent changer suivant un langage de programmation
donné car chacun possède sa syntaxe, mais pour la plupart (Comme le Java, le C#, le PHP,
etc.), ils s’utilisent de la même façon.
IV.2. TYPE DES BOUCLES
IV.2.1. Critères à prendre en compte dans l’utilisation des boucles
Pour qu’une boucle soit correctement utilisée en évitant soit de ne point y entrer ou soit
d’aboutir à une boucle infinie, il est important de considérer les trois éléments suivants :
- Initialisation : Désigne le fait de pouvoir prévoir que la boucle s’exécute au moins
une fois. Si elle n’est pas présente, cela signifie qu’en aucun cas la condition
d’évaluation ne sera vraie, avec comme conséquence que vous ne pourrais jamais
exécuter le contenu de la boucle ;
- Condition : Désigne le critère permettant à la boucle de continuer ou de s’arrêté :
Si la condition est vraie, la boucle peut continuer, et si en revanche elle est fausse ; la
boucle s’arrête automatiquement ;
- Incrémentation/Décrémentation : Désigne l’élément permettant à la condition de la
boucle de pouvoir évaluer à chaque fois une condition différente de la précédente, de
sorte à permettre à la boucle d’avancer et non de stagner.
25
IV.2.2. La boucle while

La boucle while (TantQue en français) permet d’effectuer un traitement tant que la
condition est vraie. Il faudra noter qu’elle est exclusive, car si la condition n’est pas respectée,
les instructions contenues dans la boucle ne s’exécuteront jamais. La boucle est exécutée ou
ne sera jamais exécutée. Ainsi, il se présente comme étant le genre des boucles pour
lesquels on ne connaît pas à première vu le nombre des tours des boucles. Lorsque vous
devrez faire une boucle infinie, c’est le type de boucle à utiliser. Sans oublier qu’une
mauvaise utilisation de ce genre de boucle peut faire planter votre ordinateur.
Exemple 21 : Boucle while1
Ecrire un programme en C++ qui d’afficher tous les nombres supérieur ou égale à 245 qui
soient strictement inférieurs à 500. Si le nombre est supérieur à 500, on quittera la boucle et on
affichera "On quitte la boucle !!". A chaque tour de boucle, on incrémentera de 30.
#include<iostream>
int main(){
int nombre = 245;
while (nombre < 500) {
cout<<"Le nombre "<<nombre<<" est inf\x82rieur \x85 500"<< endl;
nombre += 30;
}
cout<< "On quitte la boucle" << endl;
return 0;
}
Exemple 22 : Boucle while2

Ecrire un programme en C++ qui d’afficher "La température est élevée" aussi longtemps
que celle – ci est supérieure à -30°, et qui affiche dans le cas contraire "La température est
maintenant basse" ; tout en sachant que la température initiale est de 10°.
26
#include<iostream>
int main(){
int temperature = 10;
while (temperature > -30) {
cout<<"La temp\x82rature "<<temperature<<" est \x82levee"<<endl;
temperature--;
}
cout<<"La temp\x82rature "<<temperature<<" est maintenant basse"<<endl;
return 0;
}
Exemple 23 : : Boucle while3

Ecrire un programme en C++ qui affiche dans une boucle infinie le message "Je suis dans
une boucle infinie".
27
#include<iostream>
int main(){
while (true) {
cout<< "Je suis dans une boucle infinie" << endl;
}
return 0;
}
IV.2.3. La boucle do …. while

La boucle do...while (Faire …. TantQue, en français) permet d’effectuer un
traitement tant que la condition est vraie ou fausse (Suivant ce que l’on veut faire) mais la
boucle s’exécutera toujours au moins une fois, que la condition soit vérifiée ou non. Et c’est à
ce point qu’elle diffère de la précédente, car il y aura toujours au moins une exécution des
instructions contenues dans la boucle. Ainsi, il se présente comme étant le genre des boucles
pour lesquels au moins un choix doit être fait, pour garantir la continuité de la boucle.
C’est le cas lorsque votre programme doit d’abord effectuer une suite d’instructions avant
d’évaluer la condition de la boucle, ce serait le cas d’un programme qui effectue une
opération mathématique (Comme l’addition par exemple) et après avoir afficher le résultat, il
demande à l’utilisateur de recommencer ou d’arrêter le programme.
Dans un autre sens, on dirait que cette boucle permet d’effectuer des traitements en
interaction avec l’utilisateur, cela signifie que la continuité de la boucle dépend du choix de
l’utilisateur.
Exemple 24 : Boucle do…while1
Ecrire un programme en C++ qui affiche le produit des deux valeurs et en affichera le résultat
aussi longtemps que l’une de ces deux nombres sera différent de 10. Aucune saisie au clavier
ne sera utile.
#include<iostream>
int main(){
int p = 1, i = 1;
do {
p = p * i;
i = i + 1;
cout<< "p = " << p << " et i = " << i << endl;
} while (i != 10);
return 0;
}
28
Exemple 25 : Boucle do…while2

Ecrire un programme en C++ qui demandera d’effectuer le produit des deux nombres réels et
en affichera le résultat aussi longtemps que l’utilisateur aura répondus 'O' ou 'o' (Oui) à un
message lui demandant s’il veut continuer. S’il répond à cette question 'N' ou 'n' (Non), le
programme s’arrêtera immédiatement. En revanche, s’il saisit une réponse invalide, on
affichera "La saisie est invalide, veuillez recommencer !!".
#include<iostream>
int main(){
double n1, n2;
bool continuer = false;
char reponse = ' ';
do {
cout<< "Saisi un reel : ";
cin >> n1;
cout<< "Saisi un second reel : ";
cin >> n2;
cout<<"Le produit de "<<n1<<" et de "<<n2<< " est " << n1*n2 << endl;
cout<< "Voulez-vous continuer (O/N) ?";
cin >> reponse;
cout<< endl;
switch (reponse) {
case 'O':
case 'o':
continuer = true;
break;
case 'N':
case 'n':
continuer = false;
break;
default:
cout<<"\nLa saisie est invalide, veuillez recommencer !!"<<endl;
continuer = true;
break;
}
} while (continuer);
return 0;
}
29
IV.2.4. La boucle for

La boucle for (Pour en français) est l’une des boucles la plus utilisée. Elle permet
d’effectuer autant des tours des boucles connues d’avance et que le développeur spécifie pour
son programme. Ici, on connaît exactement le nombre de fois que la boucle va tourner avant
même d’exécuter son programme. Ce type des boucles et très utilisé en programmation car les
tableaux sont presque toujours parcourus à l’aide de ce type de boucle, étant donné que le
nombre d’éléments du tableau est une information que l’on connaît souvent d’avance.
Exemple 26 : Boucle for
Ecrire un programme permettant d’afficher 10 fois "Je suis content".
#include<iostream>
int main(){
for (int i = 0; i < 10; i++) {
cout<< "Je suis content\n";
}
return 0;
}
IV.2.5. Mots clés « break », « continue » et « goto »

L’utilisation des boucles fait souvent intervenir deux instructions qui sont break et
continue. Le mot clé break permet de quitter une boucle quel que soit le nombre des tours
qu’il devrait effectuer tan disque continue permet d’ignorer le traitement d’une boucle et
30
d’exécuter les instructions qui suivent.

Pour ce qui est de l’instruction goto, il est souvent utilisé pour effectuer un renvoie,
c’est – à – dire interrompre le traitement en cours et d’aller directement exécuter un autre bloc
d’instructions dans le même programme. Il n’est pas d’usage dans tous les langages de
programmation, c’est pourquoi il est conseillé de ne pas trop en faire un élément de
prédilection, mais de l’utiliser s’il est vraiment important. En outre, sa syntaxe est la suivante
: goto étiquette; où étiquette est une étiquette marquant la ligne de destination dans le
programme. Les étiquettes sont simplement déclarées avec la syntaxe suivante : étiquette:
Exemple 27 : Utilisation de l’instruction break
#include<iostream>
int main(){
for (int i = 0; i < 20; i++) {
cout<< "Affichage de " << i << endl;
if (i == 12) break;
}
return 0;
}
Exemple 28 : Utilisation de l’instruction continue
#include<iostream>
int main(){
for (int i = 0; i < 20; i++) {
if (i == 12) continue;
else cout<< "Affichage de " << i << endl;
}
return 0;
}
31
Exemple 29 : Utilisation de l’instruction goto

Ecrire un programme permettant de renvoyer à un message d’erreur à chaque fois que l’on fait
une division par zéro pour afficher un message.
#include<iostream>
int main(){
erreur:{
cout<< "\nErreur, pas de division par z\x82ro\n";
}
float dividende, diviseur;

cout<< "Saisi le dividende : ";
cin >> dividende;
cout<< "Saisi le diviseur : ";
cin >> diviseur;
if (diviseur == 0) goto erreur;
else cout<< "\nLa division de '" << dividende << "' et de '" << diviseur
<< "' est :" << dividende / diviseur << "\n";
return 0;
}
IV.3. EXERCICES D’APPLICATION DU CHAPITRE 4

Ex14. Ecrire un programme qui calcule les racines carrées de nombres fournis au clavier. Il
s’arrêtera lorsqu’on lui fournira la valeur 0. Il refusera les valeurs négatives.
32
Ex15. Afficher à l’écran ISIG/GOMA autant de fois que l’utilisateur l’aura spécifié au
clavier.
Ex16. Ecrire un programme qui permet d’afficher les tables de multiplications des nombres
de 0 à 10.
Ex17. Ecrire un programme qui permet d’afficher la table de multiplication des nombres de 1
à n qui sera spécifiée par l’utilisateur.
Ex18. Ecrire un programme qui calcul le factoriel d’un nombre entier saisi au clavier. Le
factoriel de 0 donnera 1 et les nombres négatifs seront refusés.
Ex19. Ecrire un programme qui affichera "Je suis en train de programmer" tant que
l’utilisateur aura saisi un nombre compris entre 27 et 53. Et qui dans le cas contraire affichera
10 fois "Je dois quitter" et on arrêtera le programme.
Ex20. Ecrire un programme qui affichera "Je suis en train de programmer" tant que
l’utilisateur aura saisi un nombre compris entre 10 et 60, sachant qu’à chaque itération,
l’utilisateur devra répondre 'O' ou 'o' à un message qui lui demandera s’il veut continuer.
S’il répond 'N' ou 'n' à ce message, le programme s’arrêtera automatiquement. Pour toute
réponse invalide, on affichera le message d’erreur "Saisie invalide, recommencez !!!", et
le programme recommencera.
Ex21. Calculer la somme des n premiers termes de la série harmonique «, c’est-à-dire la
somme : 1 + 1/2 + 1/3 + 1/4 + ..... + 1/n. La valeur de n sera saisie au préalable.
33
CHAPITRE V : LES TABLEAUX

V.1. DEFINITION
Les tableaux sont des variables qui permettent de contenir plusieurs variables de même
type.
V.2. UTILISATION DES TABLEAUX
Les tableaux sont un type de variables très particulier, c’est ainsi qu’on peut avoir un
tableau des entiers, des réels, des strings, etc. De ce fait, la déclaration des tableaux est
identique à celle des variables ; mais il faut spécifier la taille du tableau en l’ajoutant entre
crochets [].
Un tableau est caractérisé par sa taille (Qui est le nombre d’éléments qu’il peut
contenir) et ses indices (Qui sont les occurrences de chaque variable élémentaire). Le nombre
d’indices d’un tableau commence toujours par zéro, ainsi sa valeur maximale est toujours un
nombre égal à la taille du tableau moins un (NombreIndiceTableau = TailleTableau – 1).
Pour un tableau de taille 10 par exemple, il possédera 10 éléments dont le premier aura
pour indice 0 et le dernier aura pour indice 9 et non 10.
V.2.1. Tableau à une dimension

La dimension d’un tableau caractérise le nombre des doubles crochets qu’il possède. Un
double crochet ([]) implique que le tableau est à une dimension (1D), deux doubles crochets
([][]) implique que le tableau est à deux dimensions (2D) ; et un triple crochet ([][][])
implique que le tableau est à trois dimensions (3D). Il est souvent rare d’utiliser des tableaux à
dimensions multiple, mais cela peut arriver dans un programme particulier et suivant un
besoin particulier. On assimile généralement l’utilisation des tableaux aux matrices, c’est ainsi
qu’un tableau à une dimension, peut-être une matrice uni-ligne ou uni-colonne ; alors que
celui à deux dimensions peut être considéré comme une matrice carrée régulière ou
irrégulière.
La définition d’un tableau se fait en faisant suivre le nom de l’identificateur d’une paire
de crochets (Simple, double, triple, etc.) contenant le nombre d’élément du tableau tout en
prenant en compte la dimension du tableau.
On peut en outre déclarer un tableau sans l’initialiser ou le déclarer en lui affectant
directement des valeurs : type identificateur[taille]([taille](...));
34
Exemple 30 : Déclaration d’un tableau à une dimension sans affectation immédiate
int tab[5];
tab[0] = 1;
tab[1] = 2;
tab[2] = 3;
tab[3] = 4;
tab[4] = 5;
Exemple 31 : Déclaration d’un tableau à une dimension avec affectation immédiate
int tab2[5] = { 7,8,9,10,11 };

tab[0] = 1;
Exemple 32. Déclaration d’un tableau à deux dimensions sans affectation immédiate
int tableau[3][2] = {};

tableau[0][0] = 1;
tableau[0][1] = -7;
tableau[1][0] = 5;
tableau[1][1] = 10;
tableau[2][0] = 8;
tableau[2][1] = 4;
Exemple 33. Déclaration d’un tableau à deux dimensions avec affectation immédiate
int tableau2[3][2]= { {2,9}, {7,5}, {8,4} };
NB : Il faudra souligner que pour les tableaux en C++, lorsque vous dépassez la taille du
tableau lors de son parcours pour l’affichage de son contenu, il arrive que le compilateur
complète les valeurs non attribuées par des adresses mémoire de façon tout à fait aléatoire. Il
est important de savoir que des tels cas ne sont pas autorisés dans d’autre langages de
programmation comme Java, C# et autres. Ainsi manipulez les tableaux de façon intelligente.
V.2.2. Accès au contenu d’un tableau

Pour pouvoir accéder au contenu des différentes cases (Cellules) d’un tableau, on doit
parcourir le tableau via une boucle (Généralement une boucle for). Le nombre des boucles à
utiliser dépends de la dimension du tableau : Cela signifie que plus la dimension du tableau
augmente, plus ; il est nécessaire d’utiliser plusieurs boucles imbriquées pour accéder à
l’ensemble de son contenu.
Exemple 34 : Utilisation et parcours tableau à une dimension
Ecrire un programme permettant de remplir un tableau des noms pour lequel la taille sera
35
saisie au préalable par l’utilisateur au clavier. Le programme refusera toute taille inférieure ou
égale à zéro. Une fois le tableau rempli, afficher son contenu pour chaque indice.
#include<iostream>
int main(){
int nombre_element_tableau = 0;
cout<< "Saisi la taille du tableau : ";
cin >> nombre_element_tableau;
if (nombre_element_tableau <= 0) {
cout<< endl << "Cette taille est invalide !!" << endl;
} else {
string tabNom[nombre_element_tableau];
for (int i = 0; i< nombre_element_tableau; i++) {
cout<< "Saisi l'\x82l\x82ment pour l'indice " << i << " : ";
cin >> tabNom[i];
}
cout<< endl << "Affichage du contenu du tableau" << endl;
cout<< "-------------------------------" << endl << endl;
for (int i = 0; i< nombre_element_tableau; i++) {
cout<<"Valeur \x85 l'indice "<<i<<" est : "<<tabNom[i]<< endl;
}
}
return 0;
}
Exemple 35 : Utilisation et parcours tableau à deux dimensions

Ecrire un programme permettant de saisir dans un tableau à deux dimensions et d’en afficher
le contenu, tout en ayant spécifié la taille du tableau au préalable.
36
#include<iostream>
int main(){
int k = 0;
cout<< "Saisi le nombre des lignes et colonnes du tableau : ";
cin >> k;
int b[k][k];
int n = 1;
cout<< "====SAISIE====\n\n";
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
cout<< "Saisi l'entier n\xf8" << n << " : ";
cin >> b[i][j];
n++;
}
}
cout<< "\n====AFFICHAGE====\n\n";
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
cout<< "b[" << i << "][" << j << "] = " << b[i][j] << endl;
}
}
return 0;
}
V.3. EXERCICES D’APPLICATION DU CHAPITRE 5
Ex22. Ecrire un programme qui affiche les lettres de votre nom dans un tableau.
Ex23. Ecrire un programme qui permet de saisir des nombres entiers qui seront stockés dans
un tableau, puis afficher le contenu du tableau. La taille du tableau dépendra du nombre que
l’utilisateur aura saisi au clavier.
Ex24. Ecrire un programme qui demande à l’utilisateur de saisir plusieurs valeurs entières et
les affichent en spécifiant ceux qui sont pair ou impair. Le nombre total des valeurs à saisir
sera spécifié par l’utilisateur au clavier.
37
Ex25. Ecrire un programme qui demande à l'utilisateur de taper des entiers et qui affiche leur
moyenne. Le nombre d’entiers à taper sera spécifié par l’utilisateur.
Ex26. Ecrire un programme qui demande à l’utilisateur de saisir une série de nombres entiers
entre 0 et 20 et les stocke dans un tableau de 10 éléments. La saisie s’arrête si l’utilisateur
saisit -1 ou si le tableau est complet. Sinon, à chaque erreur de saisie, l’utilisateur doit
recommencer.
Ex27. Ecrire un programme qui demande à l’utilisateur de saisir plusieurs valeurs entières et
les affichent dans l’ordre LIFO (Ordre inversée, Last In First Out).
Ex28. Ecrire un programme qui demande à l’utilisateur de saisir plusieurs valeurs entières
après avoir spécifié leurs nombres et qui va ensuite les trier par ordre croissante.
Ex29. Même exercice que Ex28 mais trier par ordre décroissante.
38
CHAPITRE VI : LES FONCTIONS

VI.1. CONCEPT GENERAL SUR LES FONCTIONS
Dès qu’un programme dépasse une ou deux pages de texte, il est pratique de pouvoir le
décomposer en des parties relativement indépendantes dont on pourra comprendre facilement
le rôle, sans avoir à examiner l’ensemble du programme. Par ailleurs, même dans un petit
programme, il est fréquent que l’on ait à réaliser en plusieurs endroits un travail identique (Par
exemple, le tri d’un tableau d’entiers). Dans ces conditions, il serait regrettable d’avoir à
introduire, à diverses reprises, des instructions identiques ou presque, car cela ne créerait
qu’une redondance inutile.
La plupart des langages permettent de réaliser ce que l’on nomme des fonctions (Il
s’agit d’instructions qu’on écrit une seule fois en leur attribuant une signature, c’est – à – dire
nom et paramètres avec leurs type de donnée). Toute fonction peut ensuite être utilisée en
tout point d’un programme en se contentant d’en écrire le nom, ou d’en faire l’appel. Cela
permet d’éviter des redondances inutiles. La « fonction informatique » peut se contenter de
réaliser un calcul et de fournir le résultat, comme une fonction mathématique ; mais elle peut
aussi effectuer une action n’ayant plus rien à voir avec un calcul (Par exemple, lecture ou
écriture d’informations) et, éventuellement, ne fournir aucun résultat.
VI.2. DEFINITION
Une fonction est un bloc d’instructions éventuellement paramétré par un ou plusieurs
arguments et pouvant ou non fournir un résultat souvent nommé « valeur de retour ». En
somme, c’est un bloc d’instructions indépendant pouvant ou non retourner un résultat.
De ce fait, on distingue les fonctions qui retournent une valeur (Appelées Fonctions) et
retournent une valeur en la passant en paramètre du mot clé return, et celle qui ne retournent
pas de valeur (Appelées Méthodes) : On dit qu’elles retournent vide ou void.
VI.3. SIGNATURE D’UNE FONCTION
La signature d’une fonction permet de pouvoir la distinguer des autres. Elle comporte
généralement deux éléments :
1. Nom de la fonction : Est tout simplement la désignation de la fonction ou sa
nomenclature ;
2. Type et nombre des paramètres ou arguments : Les paramètres ou les arguments
d’une Fonction/Méthode sont des variables locales à la fonction qui doivent être
39
obligatoirement référencés lors de l’appel de la Fonction/Méthode. Elles servent en

outre à effectuer des actions (Calculs et autres) dans le corps de la fonction. Ces
dernières possèdent un type de donné qui corresponds à l’un de ceux vus dans la
partie des variables (int, float, double, string, char, objet, etc.). Le nombre des
paramètres fournissent un détail important conduisant à ce que l’on appelle la
surcharge des fonctions.
Exemple 36 : Eléments constitutif d’une fonction
float fonction_exemple(float x, int b, string c)//En-tête de la fonction

{
float value;//Variable de retour
//Corps de la fonction
return value;//Retour de la valeur
}
L’en-tête précise le nom de la fonction (fonction_exemple), le type de retour (float s’il

s’agit par exemple d’une fonction et void s’il s’agit d’une méthode) ainsi que le nombre et le
type de ses arguments (x qui est float, b qui est int et c qui est string). Le corps est un
bloc d’instructions qui définit le rôle de la fonction et se place toujours entre accolades pour
les délimiter. A la fin, intervient le mot clé return (Qui peut être omis dans le cas d’une
méthode) avec la valeur qui doit être retournée passée en paramètre.
Il faut noter que les fonctions sont de deux types, à savoir : les fonctions prédéfinies de
C++ et les fonctions personnalisées. Les fonctions prédéfinies de C++ sont celles qui sont
incorporées dans les bibliothèques de C++ et vous n’avez qu’à les utiliser mais non plus à le
recréées. Il en existe plusieurs et nous en donnons quelques-unes d’entre elles dans le tableau
ci – dessous. L’utilisation de ces fonctions nécessite l’appel de la bibliothèque dans laquelle
sont contenues ces différentes fonctions : C’est le cas par exemple de la bibliothèque cmath
qui permet l’utilisation des fonctions mathématique comme le sinus par exemple, la
bibliothèque vector pour l’utilisation des tableaux dynamique, etc. Pour s’en servir, on
ajoute l’instruction #include<cmath> pour les fonctions mathématiques et #include<vector>
pour l’utilisation des tableaux dynamiques, etc.
Les fonctions personnalisées comme son nom le dit sont celles que le développeur crée
et façonnent pour répondre à un besoin spécifique lorsqu’il programme. Ainsi, c’est à ce
dernier de lui donner un contenu pour une utilisation adéquate.
40
Désignation de la Nom de la
Exemple
fonction fonction en C++
Racine carrée sqrt() double racinecaree = sqrt(valeur);
Sinus sin() double sinusnbr = sin(valeur);
Cosinus cos() double cosinusnbr = cos(valeur);
Tangente tan() double tangentenbr = tan(valeur);
Exponentiel exp() double exponentielnbr = exp(valeur);
Logarithme népérien log() double lognbr = log(valeur);
Logarithme en base 10 log10() double log10nbr = log10(valeur);
Valeur absolue fabs() double absolunbr = fabs(valeur);
Arrondi vers le bas floor() double arrondi_bas_inbr = floor(valeur);
Arrondie vers le haut ceil() double arrondi_haut_nbr = ceil(valeur);
Exposant pow() double var_AexposantB = pow(A,B);
VI.3. UTILISATION DES FONCTIONS

Pour pouvoir se servir des Fonctions/Méthodes, on procède par 3 (Trois) étapes ; à
savoir :
1. Déclaration de la fonction : Elle consiste à signaler au compilateur que la
Fonction/Méthode spécifiée sera utilisée dans le programme.
2. Définition de la fonction : Permet de déterminer les traitements à effectuer
dans le corps de la Fonction/Méthode.
3. Appel de la fonction : C’est l’invocation de l’exécution de la
Fonction/Méthode en passant les paramètres appropriés et en respectant le type de
retour. Cette opération s’effectue juste en mentionnant le nom de la fonction et avec
ses paramètres suivant leurs types dans les cas échéants. En considérant l’exemple
36, nous écrirons : float ma_variable = fonction_exemple(12.4,7,″ mars″). Il
est important de signaler que lorsque la fonction retourne une valeur, celle – ci peut
être affectée dans une variable de même type ou être utilisé dans une opération
mathématique.
Exemple 37 : Utilisation fonction
Ecrire un programme permettant d’effectuer la somme de deux nombres réels et d’en afficher
le résultat. On interdira les valeurs inférieures à zéro.
41
#include<iostream>
//Déclaration fonction avec 2 paramètres rééls
double addition(double, double);
int main(){
cout<< "Appel de l'addition de deux nombres positifs" << endl;
//Appel de la fonction
cout<< "R\x82sultat1 = " << addition(-4, 8) << endl;
cout<< "R\x82sultat2 = " << addition(10, 15) << endl;
cout<< "R\x82sultat3 = " << addition(22.5, 27.5) << endl;
return 0;
}
//Définition de la fonction addition avec deux paramètres réels
double addition(double nbr1, double nbr2) {
double somme = 0;
if (nbr1<0 || nbr2<0)
cout<<"Seuls les nombres strictements positifs sont valides" << endl;
else
somme = nbr1 + nbr2;
return somme;
}
VI.4. PORTEE DES VARIABLES

La portée d’une variable spécifie le degré de visibilité d’une variable par rapport au
corps d’un programme. Ce concept est très capital car si l’on n’en prend pas garde, nos
programmes auront des résultats biaisés et inattendus.
VI.4.1. Variables globales

Une variable déclarée en dehors de toute Fonction/Méthode (Y compris du main) est
dite globale au programme. La portée d’une variable globale est celle de tout le programme.
Les variables globales ont une classe d’allocation statique, ce qui signifie que leurs
emplacements en mémoire restent fixes pendant l’exécution du programme. Etant donné que
les variables globales sont déclarées en dehors de toutes les fonctions, ils ont un impact dans
l’ensemble du programme et sont de ce fait visibles de n’importe quel endroit du programme.
42
Exemple 38 : Utilisation variable globale
#include<iostream>
int nbr = 20;
int main(){
cout<<"Affichage du contenu d'une variable globale : " << nbr++ << endl;
cout<<"Affichage du contenu d'une variable globale : " << --nbr << endl;
cout<<"Affichage du contenu d'une variable globale : " << nbr << endl;
return 0;
}
VI.4.2. Variables locales

Une variable déclarée dans une Fonction/Méthode est dite locale à celle – ci. Par
extrapolation, cela est vrai lorsqu’il s’agit de n’importe quel bloc d’instruction délimité par
des accolades : Toute variable déclarée dans ce bloc d’instruction est locale à ce bloc par
rapport à toute autre instruction. La portée d’une variable locale est limitée au bloc
d’instruction dans lequel elle est définie. Les variables locales ont une classe d’allocation
automatique, ce qui signifie qu’elles sont allouées à l’entrée du bloc d’instruction, et libérés à
sa sortie.
On peut demander qu’une variable locale soit de classe d’allocation statique, en la
déclarant à l’aide du mot-clé static, comme dans : static int i = 0;.
Exemple 39 : Utilisation variable globale et locale
43
#include<iostream>
int main(){
int nombre = 20;//Variable local au bloc main
cout<< "Affichage contenu variable locale \x85 'main' nombre = " << nombre
<< endl;
for (int i = 0; i<3; i++) {
int nombre2 = nombre*i;//Variable locale à for et globale à if
cout<< "Affichage contenu variable locale au bloc 'for' et global au '
if' nombre2 = " << nombre2 << endl;
nombre += nombre2;
if (nombre > 10) {
int nombre3 = nombre2 * 3;//variable local au bloc if seulement
cout<< "Affichage contenu variable locale au bloc 'if' nombre3 = "
<< nombre3 << endl;
nombre += nombre3;
}
}
cout<< "Affichage contenu variable globale avec op\x82rations aux autres v
ariables locales = " << nombre << endl;
return 0;
}
VI.5. SURCHARGE ET REDEFINITION DES FONCTIONS ET METHODES

Surcharger une fonction ou une méthode signifie tout simplement en créer une autre
possédant le même nom mais avec un nombre d’arguments différents ou de type différents
(Le type de retour n’est pas pris en compte). Ainsi, la surcharge des fonctions et des méthodes
permet d’avoir plusieurs appels à une même fonction ou une même méthode tout en faisant
des traitements tout à fait différents. En revanche redéfinir une fonction ou méthode, consiste
à en créer une autre possédant exactement le même nom, le même nombre des paramètres et
types de donné ; donc la même signature : Ce concept est particulièrement utilisé en
Programmation Orientée Objet pour mettre en œuvre le polymorphisme.
Exemple 40 : Surcharge des Fonctions/Méthodes
Ecrire un programme utilisant une fonction/méthode permettant de souligner. La première
sans argument souligne avec un caractère prédéfini, l’autre reçoit un paramètre correspondant
au caractère à utiliser pour souligner autant de fois au choix, et la dernière reçoit deux
paramètres permettant respectivement de spécifier le caractère à utiliser pour le soulignement
et un nombre renseignant sur le nombre de fois que le dit caractère sera reproduit.
44
#include<iostream>
void souligner();
void souligner(char);
void souligner(char, int);
int main(){
cout<< "Soulignement normal" << endl;
souligner();
cout<< endl;
cout<< "Soulignement par un caract\x8are fixe " << endl;
souligner('*');
cout<< endl;
cout<< "Soulignement pour un nombre d'un caract\x8are fixe"<< endl;
souligner('_', 47);
cout<< endl;
return 0;
}
void souligner() {
for (int i = 0; i < 19; i++) cout<< "^";
}
void souligner(char caractere) {
for (int i = 0; i < 39; i++) cout<< caractere;
}
void souligner(char caractere, int nbr_caractere) {
for (int i = 0; i < nbr_caractere; i++) cout<< caractere;
}
NB : L’instruction return sert à la fois à fournir une valeur de retour et à mettre fin à
l’exécution de la fonction. Elle peut mentionner une expression ou apparaître à plusieurs
reprises dans une même fonction sans problèmes. Lorsqu’une fonction ne fournit aucun
résultat, son en-tête et sa déclaration comportent le mot clé void à la place du type de la
valeur de retour, comme dans : void fonctionSansValeurRetour(...) ; lorsqu’elle ne reçoit
aucun argument, l’en-tête et la déclaration comportent une liste vide, comme dans : int
fSansArguments(), et il n’est pas nécessaire d’ajouter void comme en langage C.
45
VI.6. EXERCICES D’APPLICATION DU CHAPITRE 6

Ex30. Ecrire un programme qui calcule le factoriel en utilisant une fonction.
Ex31. Écrire :
o Une fonction, nommée f1, permettant d’afficher "bonjour" (elle ne possédera aucun
argument, ni valeur de retour) ;
o Une fonction, nommée f2, qui affiche "bonjour" un nombre de fois égal à la valeur
reçue en argument (int) et qui ne renvoie aucune valeur ;
o Une fonction, nommée f3, qui fait la même chose que f2, mais qui, de plus, renvoie la
valeur (int) 0.
Écrire un petit programme appelant successivement chacune de ces 3 fonctions, après les
avoir convenablement déclarées.
Ex32. Ecrire un programme qui utilise une fonction qui retourne la somme de deux nombres
entiers passés en paramètre de la fonction.
Ex33. Ecrire un programme avec une fonction qui reçoit en arguments 2 nombres flottants
et un caractère, et qui fournit un résultat correspondant à l’une des 4 opérations
appliquées à ses deux premiers arguments, en fonction de la valeur du dernier, à savoir :
addition pour le caractère +, soustraction pour -, multiplication pour * et division pour / (tout
autre caractère que l’un des 4 cités sera interprété comme une addition). On tiendra compte
des risques de division par zéro.
Ex34. Ecrire 2 fonctions à un argument entier et une valeur de retour booléenne qui sera
vrai si l’argument reçu est multiple de 2 (pour la première fonction) ou multiple de 3 (pour la
seconde fonction) ou fausse dans le cas contraire.
Ex35. Ecrire une fonction permettant d’ajouter une valeur fournie en argument à une autre
variable fournie également en argument et d’en afficher leur résultat.
Ex36. Ecrire une un programme qui utilise une fonction permettant de retourner le plus
grand de deux nombres entiers passés en paramètres de la fonction.
Ex37. Même exercice que le précédent mais avec 3 nombre entiers passés en paramètre.
46
CHAPITRE VII : LES STRUCTURES

VII.1. DEFINITION
Nous avons vu dans les pages précédentes les tableaux qui permettaient de conserver
plusieurs valeurs de même type au sein d’une seule et même variable, c’est ainsi que nous
avions eu des tableaux des entiers (Contenant des valeurs entières), des tableaux des strings
(Contenant des chaînes des caractères), etc.
Il est souvent utile de stocker des valeurs de types différents (int, float, string, long,
etc.), et c’est à ce moment que les tableaux deviennent inutilisables. C’est pour palier à ce
problème que les structures ont été mises au point.
Ainsi, une structure est une entité capable de regrouper des valeurs des types différents.
Ils s’utilisent via le mot clé struct. De ce fait, avant d’utiliser une structure, il faut
premièrement la déclarée comme ceci (Attention au point-virgule à la fin, car il s’agit d’une
instruction) :
Exemple 41 : Déclaration d’une structure
struct record {
int numero = 0;
int qte = 0;
float prix = 0;
string caracteristique[2] = {};
};
Cette déclaration définit un type (Modèle) de structure mais ne réserve pas de variables
correspondant à cette structure. Ce type s’appelle ici record et il précise le nom et le type de
chacun des champs constituant la structure (numero, qte et prix). Une fois un tel type de
donné défini, nous pouvons déclarer des variables de ce type correspondant (De type de cette
structure). Par exemple, l’instruction : record article1, article2; réserve deux
emplacements nommés article1 et article2, de type record ; destinés à contenir chacun deux
entiers, un flottant et un tableau de deux chaines des caractères. Les champs d’une structure
peuvent être de n’importe quel type de base, d’un type tableau ou structure. De même, les
éléments d’un tableau peuvent être d’un type structure.
VII.2. INITIALISATION DES STRUCTURES
Les structures ne sont pas initialisées par défaut. A l’instar d’un tableau, une structure
peut être initialisée lors de sa déclaration, comme dans cette instruction qui utilise le type
47
record défini précédemment :
Exemple 42 : Initialisation d’une structure
record article1 = { 1, 10, 28.5, "Verte", "Emballage en carton" };

record article2 = { 2, 7, 63.5, "Rouge", "Emballage en sachet" };
OU
record article1 = { 1, 10, 28.5, { "Verte","Emballage en carton" } };

record article2 = { 2, 7, 63.5, { "Rouge","Emballage en sachet" } };
OU
article1.numero = 1;
article1.qte = 10;
article1.prix = 28.5;
article1.caracteristique[0] = "Verte";
article1.caracteristique[1] = "Emballage en carton";
article2.qte = 7;
article2.caracteristique[0] = "Rouge";
article2.caracteristique[1] = "Emballage en sachet";
Ainsi, dans cet exemple, nous affectons des valeurs aux différentes variables de type
structure.
VII.2. UTILISATION DES STRUCTURES
Un champ d’une structure peut être manipulé comme n’importe quelle variable du type
correspondant (char, int, float, double, sting, etc.). On désigne un champ donné en faisant
suivre le nom de la variable structure de l’opérateur « point » (.), suivi du nom du champ. Un
détail important à signaler est que l’utilisation des structures nécessite que leur définition
soit faite avant ou après celle de main. L’utilisation d’une structure, en évoque son appel.
Nous donnons ici-bas un exemple complet sur l’utilisation des structures.
Exemple 43 : Utilisation d’une structure
Ecrire un programme permettant d’affecter plusieurs valeurs correspondantes à un article
(Numéro, Quantité, Prix ainsi que les caractéristiques), et d’en afficher le contenu en utilisant
des structures.
48
#include<iostream>
struct record {
int numero = 0;
int qte = 0;
float prix = 0;
string caracteristique[2] = {};
};
int main(){
record article1, article2;
//record article1 = { 1, 10, 28.5,"Verte","Emballage en carton" };
//record article2 = { 2, 7, 63.5,"Rouge","Emballage en sachet" };
article1.qte = 10;
article1.caracteristique[0] = "Verte";
article1.caracteristique[1] = "Emballage en carton";
article2.qte = 7;
article2.caracteristique[0] = "Rouge";
article2.caracteristique[1] = "Emballage en sachet";
cout<< "Affichage pour article1" << endl;

cout<< "***********************" << endl << endl;
cout<< "Num\x82ro : " << article1.numero << endl;
cout<< "Quantit\x82 : " << article1.qte << endl;
cout<< "Prix : " << article1.prix << endl;
cout<< "Caracteristique1 : " << article1.caracteristique[0] << endl;
cout<< endl << "Affichage pour article2" << endl;

cout<< "***********************" << endl << endl;
cout<< "Num\x82ro : " << article2.numero << endl;
cout<< "Quantit\x82 : " << article2.qte << endl;
cout<< "Prix : " << article2.prix << endl;
return 0;
}
49
VII.3. EXERCICES D’APPLICATION DU CHAPITRE 7

Ex38. Ecrire un programme qui fait la somme des deux temps (Heure et minutes de cours
théorique ; heures et minutes des TP) pour donner un troisième temps correspondant au
temps total de cours (Cours théorique et TP) et c’est ce dernier qui sera affiché.
Ex39. Ecrire un programme qui permet de saisir les valeurs d’un article (Numéro,
Désignation, Qte, Prix unitaire, Conditionnement et stock) dont le nombre sera spécifier
en entrée par l’utilisateur et qui après avoir fait la mise à jour du stock, affiche la situation des
toutes les entrées en stock et la valeur du stock. La valeur du stock ne sera pas saisie mais se
mettra automatiquement à jour.
50
CHAPITRE VIII : LES POINTEURS

VIII.1. INTRODUCTION SUR LES POINTEURS
Il est important de savoir que le Processeur (Microprocesseur) d’un ordinateur ne sait
pas comprendre les noms et les lettres, il se réfère aux emplacements mémoires utilisant des
chiffres hexadécimaux : c’est – à – dire utilisant une notation hexadécimale.
Généralement, on ne connait pas les adresses mémoires, mais ils sont utilisés
indirectement via des variables qui sont déclarées par-ci et par-là. De la sorte, les pointeurs
sont capables de nous permettre de manipuler des adresses mémoires, pour tout simplement
dire qu’un pointeur est une variable contenant une adresse mémoire. En d’autres termes,
nous dirons qu’un pointeur contient la référence numérique de l’emplacement mémoire d’une
autre variable : c’est pourquoi on dit qu’il pointe sur un emplacement mémoire.
a 5 0x220004
b 3 0x220008
c 8 0x22000C
p 0x220004 0x220010
Figure 3 : Représentation d’un pointeur

Il faut retenir que les pointeurs ont aussi leurs types de données.
VIII.2. DECLARATION D’UN POINTEUR
Pour pouvoir déclarer un pointeur d’un type de donné quelconque (char, int, float,
etc.), on fait précéder le nom de la variable pointeur du signe étoile ou star (*) tout en mettant
au début le type de donné.
Pour signifier que le pointeur pointe sur un emplacement mémoire spécifique, on lui
donne la valeur de l’adresse mémoire voulue en utilisant le caractère "Et Commercial" (&).
Etant donné qu’en un moment donné, le pointeur pointe sur un contenu spécifique, on peut
changer sa valeur le long du programme : Illustrons tout ceci par cet exemple :
Exemple 44 : Déclaration – Pointage et Modification pointeur
51
#include<iostream>
int main(){
int *p;//Déclaration d’un pointeur p de nombre entier
cout<< "Adresse m\x82moire initiale : p = " << p << endl;
cout<< "Valeur initiale : *p = " << *p << endl;
int a = 15;
cout<< "Adresse m\x82moire : a = " << &a << endl;
p = &a;//Le pointeur p pointe sur l’adresse mémoire de la variable a
cout<< "Adresse m\x82moire avant modification : p = " << p << endl;
cout<< "Valeur avant modification : *p = " << *p << endl;
*p = 10;//Modification de la valeur pointée par le pointeur
cout<< "Adresse m\x82moire apr\x8as modification : p = "<<p << endl;
cout<< "Valeur apr\x8as modification : *p = " << *p << endl;
cout<< "Valeur apr\x8as modification : a = " << a << endl;
return 0;
}
Exemple 45 : Utilisation pointeur
#include<iostream>
int main(){
int a = 10;
int b = 20;
int c = 30;
int *pa = &a;

int *pb = &b;
int *pc = &c;
cout<< "La valeur m\x82moire de a = " << pa << endl;
cout<< "La valeur m\x82moire de b = " << pb << endl;
cout<< "La valeur m\x82moire de c = " << pc << endl;
cout<< "\nAffichage des valeurs avec le pointeur\n";
cout<< "\**************************************\n\n";
cout<< "La valeur de la variable a = " << *pa << endl;
cout<< "La valeur de la variable b = " << *pb << endl;
cout<< "La valeur de la variable c = " << *pc << endl;
return 0;
}
52
De la même façon que nous avons eu à effectuer des opérations avec des variables
simples (Addition, Soustraction, multiplication, etc.), il est aussi possible d’en faire de la sorte
avec les pointeurs, tout en respectant leur syntaxe (Différentier valeur et adresses mémoire).
Exemple 46 : Multiplication des deux nombres en utilisant les pointeurs et adresses
mémoire
#include<iostream>
void multiplicationPointeur(double*, double*);
void multiplicationAdresse(double&, double&);
int main(){
double nb1 = 0, nb2 = 0, res = 0;
double *pointeur1, *pointeur2;//Création des deux pointeurs
cout<< "Saisi un nombre reel : ";
cin >> nb1;
cout<< "Saisi un autre nombre reel : ";
cin >> nb2;
pointeur1 = &nb1;//le pointeur pointeur1 pointe à présent au contenu situé
dans l'adresse mémoire de nb1
pointeur2 = &nb2;//le pointeur pointeur2 pointe à présent au contenu situé
dans l'adresse mémoire de nb2
multiplicationAdresse(nb1, nb2);
multiplicationPointeur(pointeur1, pointeur2);
// multiplicationPointeur(&nb1, &nb2); Idem que précédemment
return 0;
}
void multiplicationPointeur(double *nombre1, double *nombre2) {

cout<< "Affichage du resultat en utilisant des pointeurs sur des adresses
memoire = " << *nombre1**nombre2 << endl;
}
void multiplicationAdresse(double &nombre1, double &nombre2) {

cout<< "Affichage du resultat en utilisant des adresses memoire = "
<< nombre1*nombre2 << endl;
}
Exemple 47 : Echange des deux variables avec et sans pointeurs

Dans cet exemple, nous allons procéder à l’échange du contenu des deux variables sans
53
pointeur (Passage par valeur), puis avec pointeur afin de voir la valeur ajoutée que nous offre
les pointeurs (Passage par référence).
#include<iostream>
void invert(int, int);
void invert(int*, int*);
// Sans pointeur
void invert(int a, int b) {
int temp = a;
a = b;
b = temp;
}
// Avec pointeur
void invert(int *c, int *d) {
int temp = *c;
*c = *d;
*d = temp;
}
int main(){
int a = 10, b = 5, c = 10, d = 5;
cout<< "Affichage avant swap :\na = " <<a <<", b = " << b <<", c = "
<< c <<", d = " << d << endl;
invert(a, b);
invert(&c, &d);
cout<< "Affichage apr\x8as swap :\na = " <<a <<", b = " << b <<", c = "
<< c <<", d = " << d << endl;
return 0;
}
Nous nous servirons des pointeurs plus particulièrement dans le chapitre suivant sur
la Programmation Orientée Objet.
54
CHAPITRE IX : INTRODUCTION A LA PROGRAMMATION

ORIENTEE OBJET EN C++
IX.1. INTRODUCTION SUR LA POO
Bien avant l’avènement des langages de Programmation Orientée Objet (POO en sigle),
on utilisait exclusivement le mode de programmation dit Procédural, lequel se servait
particulièrement des méthodes et fonctions pour effectuer un quelconque traitement.
Très rapidement, il s’est avéré qu’il était difficile, voire impossible de réutiliser un
même bloc d’instructions sans pour autant le reproduire, violant ainsi le principe : DRY (Don’t
Repeat Yourself). Pour chercher à pallier ce problème de redondance récurrent, on a
imaginé le style de programmation basé sur la réutilisation : C’était la naissance de la
Programmation Orientée Objet.
En effet, ce type de programmation a permis un développement beaucoup plus avancé
de l’industrie de conception des programmes informatiques (Génie Logiciel).
En outre, cette programmation oblige à utiliser le paradigme propre à ce genre de
programmation, qui n’est rien d’autre que l’utilisation des classes et des objets.
IX.2. LES TROIS PILLIERS DE LA POO
Pour bien programmer en Orienter Objet, quelques concepts clés sont utiles à connaitre ;
il s’agit de :
- Classe : Est la représentation d’un élément matériel ou immatériel. Les noms
des classes respectent la nomenclature des variables, mais ils commencent toujours
par une lettre Majuscule : Cela signifie qu’ils ne doivent commencer par un chiffre
mais commencent par une lettre ; n’admettent pas des caractères spéciaux, excepté le
Under score ou tiret d’en-bas ; peuvent combiner les chiffres et les lettres.
Ex : Point, Gaz, Personne, Planete, Telephone, etc.
- Objet : Est une instance d’une classe. C’est une occurrence d’une classe.
- Propriété / Attribut : Sont des variables d’une classe.
- Méthode : Caractérise une action qui peut être effectuée par une classe.
La POO est basée sur trois éléments clés permettant leur utilisation adéquate, qui sont :
l’encapsulation, l’héritage et le polymorphisme.
55
- L’encapsulation : Est le fait de cacher les données (Attributs ou propriétés et

méthodes) dans des objets. L’encapsulation rend possible toute sorte d’opérations sur
les classes tout en se rassurant qu’elles s’appliquent sur les données que l’on cible.
- L’héritage : Est le concept permettant à une classe d’hériter les propriétés
d’une autre classe. Pour bien distinguer qu’un élément est une classe qui hérite (Classe
fille ou classe dérivée) d’une autre (Classe de base, classe mère ou classe principale),
il suffit d’avoir une affirmation sur le fait qu’il est de ce type (… est …).
Exemple 48 : Exemple de classe
Un Etudiant est une Personne : Vrai ; cela signifie que Etudiant est une classe
dérivée de Personne.
La Terre est une Planete : Vrai ; cela signifie que Terre est une classe dérivée de la
classe Planete.
Une Gourde est un Animal : Faux ; cela signifie que Gourde n’est pas une classe
dérivée de la classe Animal.
Le Chat est un Herbivore : Faux ; cela signifie que Chat n’est pas une classe dérivée
de la classe Herbivore.
- Polymorphisme : Est dit du comportement multi (Poly) forme (Morph) que
présente les classes liées par une classe mère (Classe Abstraite ou Interface), à avoir
des comportements différents suivant la classe fille désignée. Nous illustrerons ce
phénomène un peu plus loin (Néanmoins, il est important de souligner que pour que
cette opération soit possible, les classes filles doivent redéfinir une ou plusieurs
méthodes/et ou fonctions de la classe de base ou classe mère ; tout en sachant que
celles - ci devront être déclarée comme étant virtuelle dans la classe parente).
Ex : virtual void afficher() = 0;
IX.3. PORTEE DES PROPRIETES D’UNE CLASSE
La portée ou la visibilité d’un attribut (Propriété) d’une classe est déterminée par le mot
clé qui lui est associé, et qui peut modifier son comportement dans un programme. Ces mots
clés sont les suivants :
- private (-) : Désigne une propriété qui ne peut être accessible qu’à l’intérieur de la
classe dans laquelle elle a été déclarée. Elles sont désignées par un signe moins (-)
dans un diagramme des classes. L’utilisation de cette portée impose de se servir de
l’encapsulation et d’utiliser les setters et les getters.
56
- public (+) : Désigne une propriété qui peut être non seulement accessible à
l’intérieur de la classe où elle a été déclarée, mais aussi dans les autres classes
extérieures à celle – ci ; mais se trouvant dans le même paquetage (Package ou
Dossier) que ce dernier. Ce mot clé assimile la propriété à une variable globale. Elle
est représentée avec un signe plus (+) dans un diagramme des classes.
- protected (#) : Désigne une propriété qui peut être non seulement accessible à
l’intérieur de la classe mère où elle a été déclarée, mais aussi dans les autres classes
filles à celle – ci. Ce mot clé assimile la propriété à une variable locale à la classe mère
et globale aux classes dérivées. Elle est représentée avec un signe dièse (#) dans un
diagramme des classes.
IX.4. UTILISATION DU CONSTRUCTEUR
Le constructeur est une méthode particulière qui est appelée automatiquement par le
compilateur lors de la création d’un objet de type de cette classe. Ses caractéristiques sont les
suivantes :
- Elle ne retourne aucune valeur : Donc, elle est toujours vide ou void mais sans le
spécifier.
- Il n’a pas besoin des respecter les trois étapes d’utilisation des Fonctions/Méthodes
(Déclaration, définition et utilisation), sa définition seule est suffisante.
- Elle est une méthode qui est toujours publique et ne peut en aucun cas être déclarée
privée ou private (Cependant, il peut l’être dans certains cas spécifiques).
- Elle porte toujours le même nom que celui de la classe.
- Elle peut être surchargée (Pas toujours obligatoire). A ce moment-là, lors de la
création d’un objet, il faudra spécifier le type de constructeur à utiliser.
Il faut en outre tenir compte du fait que dans certains langages de programmation, la
définition du constructeur est obligatoire même si l’on ne va y mettre aucune instruction, ce
qui n’est pas le cas pour C++. Néanmoins, il est fortement recommandé de toujours ajouter le
constructeur de la classe.
Par opposition, au constructeur qui interviens lors de la création d’un objet (En
initialisant les variables de la classe soit à des valeurs spécifiques ou en avec leurs valeurs par
défaut dépendant du type de donné : 0 pour int, 0.0 pour float et double, etc.), nous avons
le destructeur (Utilisé avec un tilde ~ devant sa déclaration) qui interviens ou qui est invoqué
lors de la destruction de l’objet qui a été créé. Enfin, le destructeur n’est pas obligatoire (Mais
57
est indispensable pour détruire des objets même s’il n’a aucun bloc d’instruction défini : En
utilisant la syntaxe suivante : delete nom_object).
Retenons que le paradigme C++ impose d’utiliser une même classe en deux fichiers
distincts : *.h pour le fichier d’en-tête et *.cpp pour le fichier des traitements. Le fichier *.h
(Ex : Personne.h) est celui qui sera utilisé pour toutes les déclarations (Il est aussi appelé
fichier d’en-tête ou fichier header) de la classe et le fichier *.cpp (Ex : Personne.cpp) sera
utilisé pour toutes les définitions des fonctions/méthodes qui ont été déclarées dans le
précédent fichier. Ceci implique alors que le fichier *.cpp puisse absolument inclure le fichier
d’en-tête (En utilisant le mot clé include) pour une association correcte des déclarations et
des définitions (Ex : #include "Personne.h"). Ainsi, nous allons procéder de cette façon
dans la suite de ce cours, tout en évitant de mettre tout le code correspondant aux classes dans
un seul fichier (Ce qui est aussi faisable, cfr. Exemple49).
Exemple 49 : Utilisation d’un Constructeur/Destructeur sans fichier en-tête
#include <iostream>
class Personne {
private:
string nom;
string prenom;
char sexe;
int age;
public:
//Constructeur normal
Personne() {
cout<< "I'am constructor without params" << endl;
}
//Constructeur surcharge
Personne(string nom, string prenom, char sexe, int age) {
this->nom = nom;
this->sexe = sexe;
this->age = age;
cout<< "I'am constructor with params" << endl;
}
//Destructeur de la classe
~Personne() {
cout<< "I'am destructor" << endl;
}
};
58
int main() {
Personne p;
Personne p1("nom", "prenom", 'M', 100);
return 0;
}
Exemple 50 : Utilisation d’un Constructeur/Destructeur avec fichier d’en-tête

Fichier d’en-tête : Personne.h
#ifndef PERSONNE_H
#define PERSONNE_H
#include <iostream>
class Personne {
public:
//Declaration Constructeur normal
Personne();
//Declaration Constructeur surcharge
Personne(string, string, char, int);
//Declaration Destructeur de la classe
~Personne();
private:
string nom;
string prenom;
char sexe;
int age;
};
#endif
Les instructions #ifndef (if not define), #define (define) et #endif (end if)
permettent à ce qu’une fois un fichier d’en-tête ajouté (Par l’instruction #include
"fichier_header.h") qu’il ne le soit qu’une et une seule fois (Quel que soit le nombre de
fois que cette instruction d’inclusion serait ajoutée). Ainsi, il garantit l’unicité de l’inclusion
du fichier header par une condition (Si le fichier d’en-tête n’est pas encore inclus, l’inclure ;
sinon ne rien faire). En outre, ces instructions ne sont vraiment utiles que pour le fichier
header et non pour celui des définitions.
59
Fichier des définitions : Personne.cpp
#include "Personne.h"
//Definition Constructeur normal

Personne::Personne() {
cout<< "I'am constructor without param" << endl;
}
//Definition Constructeur surcharge
Personne::Personne(string nom, string prenom, char sexe, int age) {
this->nom = nom;
this->sexe = sexe;
this->age = age;
}
//Definition Destructeur de la classe
Personne::~Personne() {
}
Fichier d’entré du programme : main.cpp
int main() {
Personne p;
Personne p1("nom", "prenom", 'M', 100);
return 0;
}
IX.5. ACCESSEURS ET MUTATEURS

Etant donné que les propriétés d’une classe sont privées ou private, et qu’il n’est pas
possible d’y accéder à l’extérieur de la classe (Ce qui oblige l’encapsulation), on se sert des
Accesseurs (Getters) et des Mutateurs (Setters) pour y arriver. Ces derniers sont toujours
de portée publique ou public, ce qui autorise leurs utilisations à l’extérieur de la classe. En
outre, ils (Accesseurs et Mutateurs) sont créés pour chaque propriété de la classe.
Exemple 51 : Utilisation d’une classe Personne avec setters, getters et pointeurs d’objets
Ecrire un programme utilisant une classe Personne (nom, prenom, sexe et age) pour lequel on
60
aura à créer tous les accesseurs et mutateurs. Afficher ensuite les valeurs affectées dans les
différents attributs de la classe en utilisant des pointeurs d’objets.
Fichier d’en-tête : Personne.h
#ifndef PERSONNE_H
#define PERSONNE_H
#include <iostream>
class Personne {
public:
//Declaration Constructeur normal
Personne();
//Declaration Constructeur surcharge
Personne(string, string, char, int);
//Declaration Destructeur de la classe
~Personne();
//Declaration ACCESSEURS-GETTERS
string getNom();
string getPrenom();
int getAge();
char getSexe();
//Declaration MUTATEURS-SETTERS
void setNom(string);
void setPrenom(string);
void setAge(int);
void setSexe(char);
//Autre declarations
void afficher();
private:
string nom;
string prenom;
char sexe;
int age;
};
#endif
61
Fichier des définitions : Personne.cpp
//Definition Constructeur normal

Personne::Personne() {
cout<< "I'am constructor without params" << endl;
}
//Definition Constructeur surcharge
Personne::Personne(string nom, string prenom, char sexe, int age) {
this->nom = nom;
this->sexe = sexe;
this->age = age;
}
//Definition Destructeur de la classe

Personne::~Personne() {
}
// Definition ACCESSEURS-GETTERS
string Personne::getNom() {
return this->nom;
}
string Personne::getPrenom() {
return this->prenom;
}
int Personne::getAge() {
return this->age;
}
char Personne::getSexe() {
return this->sexe;
}
// Definition MUTATEURS-SETTERS
void Personne::setNom(string nom) {
this->nom = nom;
}
void Personne::setPrenom(string prenom) {
this->prenom = prenom;
}
void Personne::setAge(int age) {
this->age = age;
}
void Personne::setSexe(char sexe) {
this->sexe = sexe;
}
62
void Personne::afficher() {
cout<< "Le nom est : " << this->nom << endl;
cout<< "Le pr\x82nom est : " << this->prenom << endl;
cout<< "L'age est : " << this->age << endl;
cout<< "Le sexe est : " << this->sexe << endl;
}
int main(){
string nom = "", prenom = "";
int age = 0;
char sexe = ' ';
Personne *p = new Personne();
//Affectation Statique
p->setNom("ISAMUNA");
p->setPrenom("Josue");
p->setAge(100);
p->setSexe('M');
//Affichage Dynamique
cout<< "\n===AFFICHAGE STATIC===\n\n";
p->afficher();
cout<< "\n---------------------\n\n";
//Affectation statique
cout<< "Saisi le nom : ";
cin >> nom;
cout<< "Saisi le prenom : ";
cin >> prenom;
cout<< "Saisi l'age : ";
cin >> age;
cout<< "Saisi le sexe : ";
cin >> sexe;
p->setNom(nom);
p->setPrenom(prenom);
p->setAge(age);
p->setSexe(sexe);
//Affichage Dynamique
cout<< "\n==AFFICHAGE DYNAMIC==\n\n";
p->afficher();
return 0;
}
63
Exemple 52 : Utilisation d’une classe Arme avec setters, getters et pointeur d’objets (1)
Ecrire un programme utilisant une classe Arme (num, nom, marque et couleur) pour lequel on
aura à créer tous les accesseurs et mutateurs. Afficher ensuite les valeurs affectées dans les
différents attributs de la classe en utilisant des pointeurs d’objets. Les valeurs des propriétés
seront affectées par une saisie au clavier via des méthodes appropriées. Le destructeur devra
être utilisé et affichera un message au choix. Enfin, on surchargera le constructeur.
Fichier d’en-tête : Arme.h
#ifndef ARME_H
#define ARME_H
#include<iostream>
class Arme {
public:
//Declaration fonctions/Methode
Arme();
Arme(int, string, string, string);
~Arme();
void saisie(Arme *);

void afficher(Arme *);
//ACCESSORS AND MUTATORS

int getNum();
string getNom();
string getMarque();
string getCouleur();
64
void setNum(int);
void setMarque(string);
void setCouleur(string);
private:
int num;
string nom;
string marque;
string couleur;
};
#endif // ARME_H
Fichier des définitions : Arme.cpp
#include "Arme.h"
Arme::Arme() {
cout<< "I'm a constructor without params" << endl;
}
Arme::Arme(int num, string nom, string marque, string couleur) {
this->num = num;
this->nom = nom;
this->marque = marque;
this->couleur = couleur;
cout<< "I'm a constructor with params" << endl;
}
Arme::~Arme() {
}
//ACCESSEURS-GETTERS
int Arme::getNum() {
return this->num;
}
string Arme::getNom() {
return this->nom;
}
string Arme::getMarque() {
return this->marque;
}
string Arme::getCouleur() {
return this->couleur;
}
65
//MUTATEURS-SETTERS
void Arme::setNum(int num) {
this->num = num;
}
void Arme::setNom(string nom) {
this->nom = nom;
}
void Arme::setMarque(string marque) {
}
void Arme::setCouleur(string couleur) {
}
void Arme::saisie(Arme *a) {
int num = 0;
string nom = "", marque = "", couleur = "";
cout<< "\n===SAISIE ARME===\n\n";

cout<< "Saisi le num : ";
cin >> num;
cin >> nom;
cout<< "Saisi la marque : ";
cin >> marque;
cout<< "Saisi la couleur : ";
cin >> couleur;
a->setNum(num);
a->setNom(nom);
a->setMarque(marque);
a->setCouleur(couleur);
}
void Arme::afficher(Arme *a) {
cout<< "\n===AFFICHAGE ARME===\n\n";
cout<< "***Je suis une arme***\n";
cout<< "***********************\n";
cout<< "Num\x82ro : " << a->getNum() << endl;
cout<< "Nom : " << a->getNom() << endl;
cout<< "Marque : " << a->getMarque() << endl;
cout<< "Couleur : " << a->getCouleur() << endl;
}
66
#include "Arme.h"
int main(){
//Arme *a;
//a = new Arme();
Arme *a = new Arme();
Arme *a1 = new Arme(0, "Arme", "Default", "Default");
/*a->setNum(1);
a->setNom("AKA 47");
a->setMarque("Russe");
a->setCouleur("Noire");*/
a->saisie(a);
a->afficher(a);
a1->afficher(a1);
delete a;//Suppression de l'objet a

delete a1;//Suppression de l'objet a1
return 0;
}
Dans le précédent programme, deux méthodes extérieures à la classe ont été utilisées
pour pourvoir effectuer la saisie et l’affichage, cela est possible, mais comme il s’agit des
classes ; il est préférable que ces méthodes soient à l’intérieur même de la classe.
67
Ce même exemple peut être fait en ignorant l’utilisation d’une méthode avec paramètre
tout en faisant recours au pointeur d’objet de la classe this (Voir Exemple 53).
Exemple 53 : Utilisation d’une classe Arme avec setters, getters et pointeurs d’objets (2)
Cet exemple est identique à celui de l’exemple 52, sauf qu’ici les méthodes saisie() et
afficher() n’ont pas de paramètre.
#ifndef ARME_H
#define ARME_H
#include<iostream>
class Arme{
public:
//Declaration fonctions/Methode
Arme();
~Arme();
void saisie();
void afficher();

int getNum();
string getNom();
string getMarque();
void setNum(int);
private:
int num;
string nom;
string marque;
string couleur;
};
#endif // ARME_H
68
#include "Arme.h"
Arme::Arme() {
cout<< "I'm a constructor without params" << endl;
}
this->num = num;
this->nom = nom;
cout<< "I'm a constructor with params" << endl;
}
Arme::~Arme() {
}
//ACCESSEURS-GETTERS
return this->num;
}
return this->nom;
}
}
}
//MUTATEURS-SETTERS
this->num = num;
}
this->nom = nom;
}
}
}
69
void Arme::saisie() {
cout<< "\n===SAISIE ARME===\n\n";
cout<< "Saisi le num : ";
cin >> this->num;
cin >> this->nom;
cout<< "Saisi la marque : ";
cin >> this->marque;
cout<< "Saisi la couleur : ";
cin >> this->couleur;
}
void Arme::afficher() {
cout<< "\n===AFFICHAGE ARME===\n\n";
cout<< "***Je suis une arme***\n";
cout<< "***********************\n";
cout<< "Num\x82ro : " << this->num << endl;
cout<< "Nom : " << this->nom << endl;
cout<< "Marque : " << this->marque << endl;
cout<< "Couleur : " << this->couleur << endl;
}
#include "Arme.h"
int main(){
//Arme *a;
//a = new Arme();
Arme *a = new Arme();
Arme *a1 = new Arme(0, "Arme", "Default", "Default");
a->afficher();
// Affectation en utilisant les Mutateurs
a->setNum(1);
a->setNom("AKA 47");
a->setMarque("Russe");
a->setCouleur("Noire");
a->afficher();
// Affectation en utilisant une méthode sans changer d’objet

a->saisie();
a->afficher();
// Affectation avec le constructeur surchargé sans changer d’objet

a1->afficher();
delete a;//Suppression de l'objet a

delete a1;//Suppression de l'objet a1
return 0;
}
70
IX.6. MISE EN PRATIQUE DE L’HERITAGE

Comme cela a été dit un peu plus haut, l’héritage permet à des classes (Dites classes
dérivées) de pouvoir hériter (Comme l’héritage d’un fils vis-à-vis de son père) les propriétés
de la classe mère.
Le principe d’héritage oblige de rassembler dans la classe de base toutes les
propriétés communes à toutes les classes filles, et de ne mettre dans chaque classe filles
que la(les) propriété(s) qui lui est(sont) particulière(s). Nous allons illustrer ceci dans le
point suivant (Point IX.7).
En outre, pour signifie qu’une classe hérite d’une autre, on utilise la syntaxe suivante :
class Classe_fille : public Classe_de_base { //Insructions de la classe};.
L’exemple complet sera donné dans le point suivant (Point IX.7).
71
IX.7. MISE EN PRATIQUE DU POLYMORHISME

Nous allons illustrer le polymorphisme de la façon suivante : Nous allons créer une
classe mère qui aura une méthode afficher() que les classes filles vont redéfinir pour
pouvoir observer le comportement polymorphe que prendra les objets de type de la classe
mère (Qui sont les objets des classes filles) qui afficherons différemment suivant l’objet de la
classe fille concernée.
Dans le diagramme des classes que nous allons tracer, nous aurons trois classes (Arme,
Arme_blanche et Arme_feu), pour lesquels les deux dernières héritent de la première (Cfr.
Symbole de l’héritage). Les trois classes possèdent chacune un constructeur et un destructeur,
à la différence que le Constructeur de la classe principale a été surchargé car l’un est sans
arguments et l’autre en possède quatre. Comme cela a été dit ci – haut, les méthodes saisie et
afficher ont toutes été redéfinies (Et non surchargées) car elles possèdent des signatures
identiques (Excepté que les classes dérivées vont surcharger la méthode saisie() pour avoir
un paramètre Pointeur d’objets de type de leurs classes respectives).
Ainsi, nous allons observer non seulement l’utilisation de l’héritage mais aussi celle du
polymorphisme (Celle-ci nous obligera d’ajouter le mot clé virtual devant la déclaration des
méthodes de la classe de base devant être redéfinies).
NB : Pour le cas de l’héritage, il est conseillé de déclarer le destructeur de la classe de base
comme étant aussi virtuel (virtual) pour éviter des comportements inattendus.
Aussi, pour avoir une méthode pure abstraite (Pour une classe Abstraite, car elle est par
définition une classe contenant au moins une méthode abstraite), il faudra égaliser la
Méthode/ou Fonction à zéro dans la partie déclaration (Fichier avec extension .h). Par
conséquent, pareil Méthode/Fonction n’ont pas des corps dans la classe mère.
Pour que les propriétés communes de la classe mère soient utilisables (Et partageables) par
les classes filles (Ou classes héritées), elles devront être déclarées comme étant protected.
Le diagramme des classes répondant aux contraintes que nous venons de poser est repris ici-
bas. En outre, il n’est pas nécessaire d’avoir des notions assez avancées en UML pour
comprendre ce diagramme de classe.
72
Figure 4 : Représentation du Diagramme des Classes pour l’héritage

Exemple 54 : Utilisation de l’héritage et du polymorphisme
#ifndef ARME_H
#define ARME_H
#include<iostream>
class Arme{
public:
//Declaration fonctions/Methodes
Arme();
73
virtual ~Arme();
virtual void saisie() = 0;
virtual void afficher() = 0;

int getNum();
string getNom();
string getMarque();
void setNum(int);
protected:
int num;
string nom;
string marque;
string couleur;
private:
};
#endif // ARME_H
#include "Arme.h"
// Constructeurs de la classe Parente

Arme::Arme() {
this->num = 0;
this->nom = "nom";
this->marque = "marque";
this->couleur = "couleur";
cout<< "I'am Constructor of Arme without params" << endl;
}
this->num = num;
this->nom = nom;
cout<< "I'am Constructor of Arme with params" << endl;
}
Arme::~Arme() {
cout<< "I'am Destructor of Arme" << endl;
}
74

return this->num;
}
return this->nom;
}
}
}
this->num = num;
}
this->nom = nom;
}
}
}
Fichier d’en-tête : Arme_feu.h
#ifndef ARME_FEU_H
#define ARME_FEU_H
#include "Arme.h"
class Arme_feu : public Arme {
public:
Arme_feu();
~Arme_feu();
void saisie(Arme_feu *);
void saisie();
void afficher();
int getLong_gachette();
float getLong_cartouche();
void setLong_gachette(int);
void setLong_cartouche(float);
private:
int long_gachette;
float long_cartouche;
};
#endif // ARME_FEU_H
75
Fichier des définitions : Arme_feu.cpp
#include "Arme_feu.h"
Arme_feu::Arme_feu() {
this->long_cartouche = 0;
this->long_gachette = 0;
cout<< "I'am Constructor of Arme_feu without params" << endl;
}
Arme_feu::~Arme_feu() {
cout<< "I'am Destructor of Arme_feu" << endl;
}
void Arme_feu::saisie() {
cout<< "\nSAISIE" << endl;
cout<< "======" << endl;
cout<< "\nArme_feu" << endl;
cout<< "------------------------" << endl;
cout<< "Saisie le num\x82ro : ";
cin >> this->num;
cout<< "Saisie le nom : ";
cin >> this->nom;
cout<< "Saisie la marque : ";
cout<< "Saisie la couleur : ";
cout<< "Saisie long gachette : ";
cin >> this->long_gachette;
cout<< "Saisie long cartouche : ";
cin >> this->long_cartouche;
}
void Arme_feu::saisie(Arme_feu *a) {
cout<< "======" << endl;
cout<< "Arme_feu" << endl;
cout<< "------------------------" << endl;
cin >> a->num;
cin >> a->nom;
cin >> a->marque;
cin >> a->couleur;
cout<< "Saisie long gachette : ";

cin >> a->long_gachette;
cout<< "Saisie long cartouche : ";
cin >> a->long_cartouche;
}
76
void Arme_feu::afficher() {
cout<< "\nAFFICHAGE" << endl;
cout<< "=========" << endl;
cout<< "Arme_feu" << endl;
cout<< "Le num\x82ro est : " << this->num << endl;
cout<< "La marque est : " << this->marque << endl;
cout<< "La couleur est : " << this->couleur << endl;
cout<< "La long gachette est : " << this->long_gachette << endl;
cout<< "La long cartouche est : " << this->long_cartouche << endl;
}

int Arme_feu::getLong_gachette() {
return this->long_gachette;
}
float Arme_feu::getLong_cartouche() {
return this->long_cartouche;
}
void Arme_feu::setLong_gachette(int long_gachette) {
this->long_gachette = long_gachette;
}
void Arme_feu::setLong_cartouche(float long_cartouche) {
this->long_cartouche = long_cartouche;
}
Fichier d’en-tête : Arme_blanche.h
#ifndef ARME_BLANCHE_H
#define ARME_BLANCHE_H
#include "Arme.h"
class Arme_blanche : public Arme {

public:
Arme_blanche();
~Arme_blanche();
void saisie(Arme_blanche *);
void saisie();
void afficher();

float getLame();
void setLame(float);
private:
float lame;
};
#endif // ARME_BLANCHE_H
77
Fichier des définitions : Arme_blanche.cpp
#include "Arme_blanche.h"
Arme_blanche::Arme_blanche() {
this->lame = 0;
cout<< "I'am Constructor of Arme_blanche without params" << endl;
}
Arme_blanche::~Arme_blanche() {
cout<< "I'am Destructor of Arme_blanche" << endl;
}
void Arme_blanche::saisie() {
cout<< "======" << endl;
cout<< "\nArme_blanche" << endl;
cout<< "------------------------" << endl;
cin >> this->num;
cin >> this->nom;
cout<< "Saisie la lame : ";

cin >> this->lame;
}
void Arme_blanche::saisie(Arme_blanche *a) {

cout<< "======" << endl;
cout<< "Arme_blanche" << endl;
cout<< "------------------------" << endl;
cin >> a->num;
cin >> a->nom;
cin >> a->marque;
cin >> a->couleur;
cout<< "Saisie la lame : ";

cin >> a->lame;
}
78
void Arme_blanche::afficher() {
cout<< "\nAFFICHAGE" << endl;
cout<< "=========" << endl;
cout<< "Arme_blanche" << endl;
cout<< "Le num\x82ro est : " << this->num << endl;
cout<< "La marque est : " << this->marque << endl;
cout<< "La couleur est : " << this->couleur << endl;
cout<< "La lame est : " << this->lame << endl;

}

float Arme_blanche::getLame() {
return this->lame;
}
void Arme_blanche::setLame(float lame) {
this->lame = lame;
}
#include "Arme.h"
#include "Arme_feu.h"
#include "Arme_blanche.h"
int main(){
//Utilisation objet Arme_feu
Arme_feu *afeu = new Arme_feu();
afeu->saisie(afeu);
afeu->afficher();
//Utilisation objet Arme_blanche

Arme_blanche *abla = new Arme_blanche();
abla->saisie(abla);
abla->afficher();
//UTILISATION POLYMORPHYSME
cout<< "\n\nAPPEL POLYMORPHE" << endl;
cout<< "----------------" << endl;
//Declaration object Arme instentie avec Arme_feu

Arme *af = new Arme_feu();
//Declaration object Arme instentie avec Arme_blanche
Arme *ab = new Arme_blanche();
79
//Appel des mehodes de la classe Arme_feu

af->saisie();
af->afficher();
//Appel des mehodes de la classe Arme_blanche

ab->saisie();
ab->afficher();
//Liberation ressources des objets

delete af;
delete ab;
delete afeu;
delete abla;
return 0;
}
80
Suite de l’exécution du programme…

81
CONCLUSION
En conclusion de ce cours, nous encourageons les étudiants à pousser loin leurs
recherches de sorte à tirer le meilleur du langage de programmation C++ et devenir alaise
dans la programmation en usant de n’importe quel langage de programmation. En outre, c’est
en s’exerçant que chacun pourra très bien se familiariser avec ce langage de programmation
qui est très proche du langage Java et de certains autres.
82
BIBLIOGRAPHIE
1. Claude Delannoy, S’initier à la programmation, Ed. Eyrolles, 2008, Paris, 300p.
2. Matthieu Nebra et Matthieu Schaller, Guide Programmer avec le langage C, Paris, 2011,
704p.
3. Matthieu Nebra et Matthieu Schaller, Guide Programmer avec le langage C++, Paris, 654p.
4. Claude Delannoy, Exercices en langage C++, Ed. Eyrolles, 2007, Paris, 352p.
5. Brian Overland, C++ without fear Second Edition, Ed. Pearson Education, 2011, USA,
581p.
6. Hugues Bersini et Ivan Wellesz, L’orienté objet (Cours et exercices en UML2 avec Java 5,
C# 2, C++, Python et PHP 5, Ed. Eyrolles, Paris, 2007, 602p.
7. www.cplusplus.com.
8. https://bloodshed.net/.
9. https://sourceforge.net/projects/orwelldevcpp/.
10. https://www.embarcadero.com/free-tools/dev-cpp
83
LISTE DES FIGURES

Figure 1 : Processus d’exécution d’un programme C++ ............................................................ 4
Figure 2 : Processus de débogage d’un programme C++ .......................................................... 5
Figure 3 : Représentation d’un pointeur ................................................................................... 50
Figure 4 : Représentation du Diagramme des Classes pour l’héritage .................................... 72
84
LISTES DES EXEMPLES

Exemple 1 : Nom des variables .................................................................................................. 7
Exemple 2 : Mon premier programme en C++ .......................................................................... 7
Exemple 3 : Utilisation de l’instruction sizeof ........................................................................... 9
Exemple 4 : Représentation valeurs décimales ........................................................................ 10
Exemple 5 : Représentation valeurs Hexadécimales................................................................ 10
Exemple 6 : Représentation valeurs Octales ............................................................................ 10
Exemple 7 : Représentation valeurs Flottantes ........................................................................ 10
Exemple 8 : Représentation des caractères .............................................................................. 11
Exemple 9 : Représentation des commentaires ........................................................................ 13
Exemple 10 : Affectation des variables.................................................................................... 14
Exemple 11 : Utilisation de l’incrémentation/Décrémentation ................................................ 14
Exemple 12 : Représentation condition ................................................................................... 17
Exemple 13 : Conditions simples1 ........................................................................................... 17
Exemple 14 : Conditions simples2 ........................................................................................... 17
Exemple 15 : Utilisation Conditions simples3 (Avec instruction conditionnelle ou ternaire). 18
Exemple 16 : Syntaxe générale des conditions alternatives ..................................................... 19
Exemple 17 : Conditions alternative1 ...................................................................................... 19
Exemple 18 : Conditions alternative2 : Switch…Case ............................................................ 20
Exemple 19 : Syntaxe générale des conditions imbriquées ..................................................... 21
Exemple 20 : Conditions imbriquées ....................................................................................... 21
Exemple 21 : Boucle while1 .................................................................................................... 25
Exemple 22 : Boucle while2 .................................................................................................... 25
Exemple 23 : : Boucle while3 .................................................................................................. 26
Exemple 24 : Boucle do…while1 ............................................................................................ 27
Exemple 25 : Boucle do…while2 ............................................................................................ 28
Exemple 26 : Boucle for........................................................................................................... 29
Exemple 27 : Utilisation de l’instruction break ....................................................................... 30
Exemple 28 : Utilisation de l’instruction continue................................................................... 30
85
Exemple 29 : Utilisation de l’instruction goto ......................................................................... 31

Exemple 30 : Déclaration d’un tableau à une dimension sans affectation immédiate ............. 34
Exemple 31 : Déclaration d’un tableau à une dimension avec affectation immédiate............. 34
Exemple 32. Déclaration d’un tableau à deux dimensions sans affectation immédiate .......... 34
Exemple 33. Déclaration d’un tableau à deux dimensions avec affectation immédiate .......... 34
Exemple 34 : Utilisation et parcours tableau à une dimension ................................................ 34
Exemple 35 : Utilisation et parcours tableau à deux dimensions ............................................. 35
Exemple 36 : Eléments constitutif d’une fonction ................................................................... 39
Exemple 37 : Utilisation fonction ............................................................................................ 40
Exemple 38 : Utilisation variable globale ................................................................................ 42
Exemple 39 : Utilisation variable globale et locale.................................................................. 42
Exemple 40 : Surcharge des Fonctions/Méthodes ................................................................... 43
Exemple 41 : Déclaration d’une structure ................................................................................ 46
Exemple 42 : Initialisation d’une structure .............................................................................. 47
Exemple 43 : Utilisation d’une structure.................................................................................. 47
Exemple 44 : Déclaration – Pointage et Modification pointeur ............................................... 50
Exemple 45 : Utilisation pointeur ............................................................................................ 51
Exemple 46 : Multiplication des deux nombres en utilisant les pointeurs et adresses mémoire
.................................................................................................................................................. 52
Exemple 47 : Echange des deux variables avec et sans pointeurs ........................................... 52
Exemple 48 : Exemple de classe .............................................................................................. 55
Exemple 49 : Utilisation d’un Constructeur/Destructeur sans fichier en-tête .......................... 57
Exemple 50 : Utilisation d’un Constructeur/Destructeur avec fichier d’en-tête ...................... 58
Exemple 51 : Utilisation d’une classe Personne avec setters, getters et pointeurs d’objets .... 59
Exemple 52 : Utilisation d’une classe Arme avec setters, getters et pointeur d’objets (1) ...... 63
Exemple 53 : Utilisation d’une classe Arme avec setters, getters et pointeurs d’objets (2) .... 67
Exemple 54 : Utilisation de l’héritage et du polymorphisme................................................... 72
86
ANNEXES : TABLE ASCII DES CARACTERES

87
88
TABLE DES MATIERES
CHAPITRE I : INTRODUCTION AUX CONCEPTS DE PROGRAMMATION ........... 0

I.1. OBJECTIF DU COURS ................................................................................................. 1
I.2. DEFINITION DES CONCEPTS CLES ......................................................................... 1
I.2.1. Application ................................................................................................................ 1
I.2.2. Programme ................................................................................................................ 1
I.2.3. Programmation .......................................................................................................... 1
I.2.4. Code .......................................................................................................................... 1
I.2.5. Code source ............................................................................................................... 1
I.2.6. Langage de programmation ...................................................................................... 2
I.2.7. Compilateur et interpréteur ....................................................................................... 2
I.3. INTRODUCTION AU LANGAGE DE PROGRAMMATION C++ ............................ 3
I.3.1. Parlons C++ .............................................................................................................. 3
I.3.2. Avec quoi développer en C++ .................................................................................. 4
I.3.3. Règle à respecter pour bien programmer en C++ ..................................................... 5
CHAPITRE II : LES VARIABLES ....................................................................................... 7

II.1. DEFINITION.................................................................................................................. 7
II.2. LES NOMS DES VARIABLES..................................................................................... 7
II.3. LES TYPES DES VARIABLES .................................................................................... 8
II.4. NOTATION DES VALEURS...................................................................................... 10
II.4.1. Valeurs entières ..................................................................................................... 10
II.4.2. Valeurs flottantes ................................................................................................... 10
II.4.3. Valeurs des caractères ........................................................................................... 10
II.5. LES OPERATEURS .................................................................................................... 11
II.5.7. Utilisation des commentaires................................................................................. 13
II.6. DECLARATION DES VARIABLES .......................................................................... 13
II.7. EXERCICES D’APPLICATION DU CHAPITRE 2 ................................................... 15
CHAPITRE III : LES STRUCTURES DE CONTROLE I : LES CONDITIONS .......... 16

III.1. INTRODUCTION ....................................................................................................... 16
III.2. TYPE DES CONDITIONS ......................................................................................... 16
III.2.1. Syntaxe générale d’une condition ........................................................................ 16
III.2.2. Les conditions simples ......................................................................................... 17
89
III.2.3. Les conditions alternatives ................................................................................... 18

III.2.4. Les conditions imbriquées .................................................................................... 21
III.3. EXERCICES D’APPLICATION DU CHAPITRE 3 ................................................. 22
CHAPITRE IV : LES STRUCTURES DE CONTROLE II : LES BOUCLES ............... 24

IV.1. INTRODUCTION ...................................................................................................... 24
IV.2. TYPE DES BOUCLES ............................................................................................... 24
IV.2.1. Critères à prendre en compte dans l’utilisation des boucles ................................ 24
IV.2.2. La boucle while .................................................................................................... 25
IV.2.3. La boucle do …. while ......................................................................................... 27
IV.2.4. La boucle for ........................................................................................................ 29
IV.2.5. Mots clés « break », « continue » et « goto »....................................................... 29
IV.3. EXERCICES D’APPLICATION DU CHAPITRE 4 ................................................. 31
CHAPITRE V : LES TABLEAUX ....................................................................................... 33

V.1. DEFINITION ............................................................................................................... 33
V.2. UTILISATION DES TABLEAUX .............................................................................. 33
V.2.1. Tableau à une dimension ....................................................................................... 33
V.2.2. Accès au contenu d’un tableau .............................................................................. 34
V.3. EXERCICES D’APPLICATION DU CHAPITRE 5 .................................................. 36
CHAPITRE VI : LES FONCTIONS .................................................................................... 38

VI.1. CONCEPT GENERAL SUR LES FONCTIONS ...................................................... 38
VI.2. DEFINITION .............................................................................................................. 38
VI.3. SIGNATURE D’UNE FONCTION ........................................................................... 38
VI.3. UTILISATION DES FONCTIONS............................................................................ 40
VI.4. PORTEE DES VARIABLES...................................................................................... 41
VI.4.1. Variables globales ................................................................................................ 41
VI.4.2. Variables locales .................................................................................................. 42
VI.5. SURCHARGE ET REDEFINITION DES FONCTIONS ET METHODES ............. 43
VI.6. EXERCICES D’APPLICATION DU CHAPITRE 6 ................................................. 45
CHAPITRE VII : LES STRUCTURES ............................................................................... 46

VII.1. DEFINITION ............................................................................................................. 46
VII.2. INITIALISATION DES STRUCTURES.................................................................. 46
90
VII.2. UTILISATION DES STRUCTURES ....................................................................... 47

VII.3. EXERCICES D’APPLICATION DU CHAPITRE 7 ................................................ 49
CHAPITRE VIII : LES POINTEURS ................................................................................. 50

VIII.1. INTRODUCTION SUR LES POINTEURS ............................................................ 50
VIII.2. DECLARATION D’UN POINTEUR ...................................................................... 50
CHAPITRE IX : INTRODUCTION A LA PROGRAMMATION ORIENTEE OBJET

EN C++ .................................................................................................................................... 54
IX.1. INTRODUCTION SUR LA POO .............................................................................. 54
IX.2. LES TROIS PILLIERS DE LA POO ......................................................................... 54
IX.3. PORTEE DES PROPRIETES D’UNE CLASSE ....................................................... 55
IX.4. UTILISATION DU CONSTRUCTEUR .................................................................... 56
IX.5. ACCESSEURS ET MUTATEURS ............................................................................ 59
IX.6. MISE EN PRATIQUE DE L’HERITAGE ................................................................. 70
IX.7. MISE EN PRATIQUE DU POLYMORHISME ........................................................ 71
CONCLUSION ....................................................................................................................... 81
BIBLIOGRAPHIE ................................................................................................................. 82
LISTE DES FIGURES........................................................................................................... 83
LISTES DES EXEMPLES .................................................................................................... 84
ANNEXES : TABLE ASCII DES CARACTERES ............................................................ 86
TABLE DES MATIERES ..................................................................................................... 88

Elements D'algorithme Et Programmation Part Two

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

Elements D'algorithme Et Programmation Part Two

Transféré par

Droits d'auteur :

Formats disponibles

ENSEIGNEMENT SUPERIEUR ET UNIVERSITAIRE

Institut Supérieur d’Informatique et de Gestion

using namespace std;

cout << "Le nombre de nombres premiers inf\x82rieurs ou egaux \x85

ELEMENTS D’ALGORITHME ET PROGRAMMATION

Dispensé par CT ISAMUNA NKEMBO Josué

Pour les étudiants de Première Année de Licence en Informatique

CHAPITRE I : INTRODUCTION AUX CONCEPTS DE

I.2. DEFINITION DES CONCEPTS CLES

I.2.6. Langage de programmation

I.2.7. Compilateur et interpréteur

La compilation consiste à traduire globalement l’ensemble du programme dit en

I.3. INTRODUCTION AU LANGAGE DE PROGRAMMATION C++

Code Source Fichier Objet

Figure 1 : Processus d’exécution d’un programme C++

I.3.2. Avec quoi développer en C++

- CodeBlocks (https://www.codeblocks.org/downloads) : Notre choix pour le cours ;

Oui Erreur Non

Figure 2 : Processus de débogage d’un programme C++

I.3.3. Règle à respecter pour bien programmer en C++

1. Importation de la bibliothèque standard d’entrée – sortie grâce à l’instruction

CHAPITRE II : LES VARIABLES

Exemple 2 : Mon premier programme en C++

II.3. LES TYPES DES VARIABLES

bool (Booléen) 1 True ou False. Ex : bool ok = false;

char (Caractère) 1 Caractère. Ex : char mon_caractere = 'K';

int (Varie par installation

Nombre réel : +/- 3.4e+/- 38 (~7 digits). Ex : float nbr3 =

Permet de représenter des chaînes des caractères.

Ce type intervient dans la Programmation Orientée Objet et objet prend

II.4. NOTATION DES VALEURS

II.4.1. Valeurs entières

- Base 16 (Hexadécimale) : Avec les chiffres 0 à 9 et A à F ou a à f (A=a=10, B=b=11,

II.4.2. Valeurs flottantes

II.4.3. Valeurs des caractères

Exemple 8 : Représentation des caractères

cout<< "\a";// Bip sonore

II.5. LES OPERATEURS

N° Opérateur Signification Utilité globale

02 - Soustraction ou changement de signe d’une grandeur arithmétique

03 * Multiplication Permettent d’effectuer des

06 % Modulo. Le reste de la division d’un nombre avec un autre.

07 < Strictement inférieur à

13 & ET Binaire Permettent d’effectuer des

20 += Ajout et affectation valeur

24 %= Modulo et affectation valeur

E. Opérateurs d’incrémentation / Décrémentation

25 ++ Incrémentation Permettent l’augmentation

27 () Fonction, Méthodes et Conditions Utilisés pour des besoins

28 {} Délimiteur de bloc d’instruction divers et variés.

29 [] Accès aux tableaux

Opérateur conditionnel : Evalue une condition en spécifiant quelle

31 -> Accès aux membres d’une classe

32 . Accès aux membres d’une classe ou d’une structure

33 : Mise au point de l’héritage

Opérateur de portée. Permet particulièrement d’avoir accès à des

II.5.7. Utilisation des commentaires

Exemple 9 : Représentation des commentaires

II.6. DECLARATION DES VARIABLES

II.7. EXERCICES D’APPLICATION DU CHAPITRE 2

CHAPITRE III : LES STRUCTURES DE CONTROLE I : LES

III.2.1. Syntaxe générale d’une condition

Exemple 12 : Représentation condition

void multiplicationPointeur(double nombre1, double nombre2) {