18 LIVRE C++ 1ère EDITION

HIT-TECHNOLOGY SARL U: www.hittechnologie.
com
LANGAGE DE PROGRAMMATION P.O.O.: C++ et Qt
www.hittechnologie.com
1ère Edition
Pour concepteur et développeur d‟applications en C++ et Qt
HIT-TECHNOLOGY SARL U
PROGRAMMATION ORIENTEE-OBJET :
COURS et EXERCICES CORRIGES
C++ et Qt
Formateur en développement applicatif

Enseignant à l‘Université de Lomé et dans les Institutions privées (Togo)
Fondateur du Cabinet HIT-TECHNOLOGY SARL U
Alassani AKANATE a.daviman@gmail.com
alassaniakanate@yahoo.fr
Tel : (+228) 90 47 51 03 / 97 31 77 52 / 93 32 77 18
01 BP : 1341 Lomé-Togo.
« L‟avenir de l‟Homme se trouve dans sa manière de penser »
© Tous droits réservés 2017-2020 HIT-T
PRIX : 1 800 F CFA

Livre Livre
par HIT-T SARL U
par HIT-T
HIT-T SARL U: web: www.hittechnologie.com E-mail: formationfacile.hitt.tg@gmail.com Tel: 90-47-51-03 /97-31-77-52
Enregistré sous le décret n° 2012-008/PR du 07-03-2012, Arrêté n° 011/MCPSP/CAB/DPSP du 13-04-2012
DANS LA MÊME COLLECTION
1 ARCHITECTURE ET INTERCONNEXION RESEAU

2 SGBD MySQL ET SQL
ANALYSE ET CONCEPTION DES SYSTEMES D‘INFORMATION (ACSI) AVEC
3
MERISE
4 SGBD MICROSOFT ACCESS 2010
5 SQL POUR MySQL ET ORACLE
6 SE-OS, CONFIGURATION ET SECURITE
6 SECURITE INFORMATIQUE ET RESEAU
8 INFORMATIQUE ET CONFIGURATION
9 OFFICE 2007-2010 ET INITIATION (Word-Excel-PowerPoint-Publisher)
DEVELOPPEMENT DE SITES WEB AVEC LE CMS/SGC JOOMLA ET LES
10
BASES DE DONNEES MySQL
11 P.O.O.: Java SE
12 P.O.O.: C++ et Qt
13 Ecrits Professionnels (EP)
14 Droit Social et de Travail (M. ALASSANI)
15 Economie Générale (M. AMANA)
16 Santé, Sécurité et Hygiène au travail (S. S. H. T.)
17 Tenue de caisse – Facturation
18 Electronique dans l‘automobile
19 Climatisation dans l‘automobile
20 MS SQL SERVER 2012-2014 et SQL / T-SQL
AVEC HIT-T SARL U, FAITES LA

DIFFERENCE !
COLLECTION HIT-T SARL U
P.O.O. : C++ et Qt : BTS/ LP/MP-HIT-T/Par A. AKANATE 1ère Edition Page 1 sur 132
A QUI S‘ADRESSE CE LIVRE

Ce livre s‘adresse aux professionnels en activités, aux chefs d‘entreprise, aux étudiants et à
toute personne désireuse d‘apprendre le langage de programmation orientée-objet (P.O.O)
C++, dans le but de pouvoir mettre en place des applications professionnelles, dynamiques et
de bonne qualité.
PREREQUIS
 Connaissance de base en informatique
 Connaissance de l‘algorithme et programmation
 Notions sur la recherche sur internet
POURQUOI CE LIVRE?
Ce livre répond aux questions des attentes des jeunes, des organisations et toute personne
désirant apprendre la programmation orientée-objet et surtout le langage C++. Le langage
C++ est l‘un des langages les plus utilisés de nos jours du fait de sa facilité d‘utilisation, sa
puissance de construction des interfaces graphiques rapide et facile. Ce livre contient outre le
cours, une collection d‘exercices et corrigés afin de permettre aux apprenants de s‘exercer.
Egalement, un glossaire a été fourni à la fin du livre.
OBJECTIFS SPECIFIQUES DE CE LIVRE

 Comprendre les différentes technologies C++,
 Connaître les outils nécessaires pour la programmation en C++,
 Comprendre les bases de la programmation,
 Comprendre le concept de la programmation orientée-objet,
 Pouvoir écrire un programme C++ et l‘exécuter en mode console,
 Pouvoir écrire des applications en mode graphique (Interfaces graphiques)
commercialisables avec l‘outil Qt,
 Avoir un lexique riche en informatique et langages de programmation.
A PROPOS
HIT-TECHNOLOGY (HIT-T) SARL U est un cabinet spécialisé dans le développement des
applications web et mobiles. Il offre également des services tels que : Les formations en
Multimédia, Informatique et Télécommunications, l‘installation des réseaux informatiques, la
maintenance informatique et réseau, la conception et la réalisation de sites web, la conception
et la réalisation des applications web et mobiles, le consulting dans le domaine de mise en
place des bases de données, des systèmes d‘information, la sécurité réseau, pour ne citer que
ces points. Les formations sont offertes dans les filières tertiaires et technologiques. Le
cabinet est enregistré sous le décret n° 2012-008 / PR du 07-03-2012, Arrêté n° 011 /
MCPSP / CAB / DPSP du 13-04-2012.
Table des matières

A QUI S’ADRESSE CE LIVRE ........................................................................................ 2
PREREQUIS .................................................................................................................... 2
POURQUOI CE LIVRE? ................................................................................................. 2
OBJECTIFS SPECIFIQUES DE CE LIVRE ................................................................... 2
A PROPOS ....................................................................................................................... 2
INTRODUCTION GENERALE ....................................................................................... 9
CHAPITRE I : PRESENTATION GENERALE DU LANGAGE C++ ET DU
PARADIGME P.O.O. ..................................................................................................... 10
INTRODUCTION .......................................................................................................... 11
1. Qu’est-ce qu’un langage ? .............................................................................................. 11
1.1. Caractéristiques d‘un langage ......................................................................................................... 11
1.1.1. Expressivité ............................................................................................................................. 11
1.1.2. Simplicité ................................................................................................................................ 11
1.1.3. Implémentation ...................................................................................................................... 11
1.1.4. Puissance ................................................................................................................................ 11
1.2. Historique générale des langages .................................................................................................... 11
1.3. Evolutions des langages .................................................................................................................. 12
1.4. Langages objets ............................................................................................................................... 12
2. Dénomination ................................................................................................................. 13
3. Histoire .......................................................................................................................... 13
4. Fonctionnalités introduites ............................................................................................. 14
5. Bibliothèque standard .................................................................................................... 15
6. Programmation orientée objet ....................................................................................... 15
6.1. Encapsulation .................................................................................................................................. 15
6.1.1. « Hello, world » ...................................................................................................................... 16
6.1.2. Espace de noms ...................................................................................................................... 16
6.1.3. Directive using ........................................................................................................................ 16
6.2. Déclaration et définition de classe ................................................................................................... 19
6.2.1. Déclaration de classe .............................................................................................................. 19
6.2.2. Définition de classe ................................................................................................................ 19
6.3. Templates ........................................................................................................................................ 20
6.3.1. Paramètres des templates ...................................................................................................... 20
6.3.2. Utilité des templates .............................................................................................................. 21
6.3.3. Exemple de templates ............................................................................................................ 21
6.3.4. Spécialisation des templates .................................................................................................. 21
6.3.5. SFINAE .................................................................................................................................... 22
6.4. Polymorphisme et méthodes virtuelles ............................................................................................ 22
7. Outils de développement ................................................................................................ 23

8. Environnements de développement ................................................................................ 23
9. Compilateurs.................................................................................................................. 23
10. Bibliothèques .............................................................................................................. 24
CONCLUSION............................................................................................................... 24
CHAPITRE II : LES BASES DU LANGAGE C++ ET LA PROGRAMMATION EN
MODE CONSOLE ......................................................................................................... 25
INTRODUCTION .......................................................................................................... 26
I. CONCEPTS DE BASE DU LANGAGE C++............................................................ 26
1. Mots réservés en C++ ..................................................................................................... 26
2. Variables ........................................................................................................................ 26
2.1. Terminologie ................................................................................................................................... 26
2.2. Types de base .................................................................................................................................. 26
2.2.1. Vide ......................................................................................................................................... 26
2.2.2. Entiers ..................................................................................................................................... 26
2.2.3. Réels ....................................................................................................................................... 27
2.2.4. Booléens ................................................................................................................................. 27
2.2.5. Chaînes de caractères ............................................................................................................. 27
2.3. Valeurs littérales (ou explicites) ...................................................................................................... 27
2.3.1. Caractères ............................................................................................................................... 27
2.3.2. Chaînes de caractères ............................................................................................................. 27
2.3.3. Valeurs entières ...................................................................................................................... 27
2.3.4. Valeurs réelles ........................................................................................................................ 27
2.4. Déclaration des variables................................................................................................................. 27
2.5. Déclaration + initialisation .............................................................................................................. 28
3. Expressions .................................................................................................................... 28
3.1. Définition ........................................................................................................................................ 28
3.2. Opérateurs arithmétiques ................................................................................................................. 28
3.3. Opérateurs d‘affectation .................................................................................................................. 29
2.5.1. Egal (=) .................................................................................................................................... 29
2.5.2. Les opérateurs composites ..................................................................................................... 29
3.4. Conversion de type .......................................................................................................................... 29
3.5. Opérateurs d‘entrées-sorties ............................................................................................................ 30
3.6. Formatage des sorties numériques .................................................................................................. 30
4. Instructions .................................................................................................................... 30
4.1. Instruction-expression ..................................................................................................................... 30
4.2. Instruction-bloc ............................................................................................................................... 30
4.3. Structures de contrôle ...................................................................................................................... 31
4.4. Visibilité d‘une variable .................................................................................................................. 31
5. Fonctions........................................................................................................................ 31
5.1. Terminologie ................................................................................................................................... 31
5.2. Déclaration d‘une fonction .............................................................................................................. 32
5.3. Définition d‘une fonction ................................................................................................................ 32
5.4. Utilisation d‘une fonction ................................................................................................................ 32
5.5. Arguments par défaut ...................................................................................................................... 33
5.6. Exemple de programme .................................................................................................................. 33
5.7. Passage des paramètres dans une fonction ...................................................................................... 35
6. Instructions conditionnelles ............................................................................................ 35

6.1. L‘instruction if ................................................................................................................................ 35
6.1.1. Opérateurs booléens .............................................................................................................. 36
6.1.2. Opérateurs de comparaison ................................................................................................... 36
6.2. L‘instruction switch......................................................................................................................... 37
6.3. Les boucles ...................................................................................................................................... 38
6.3.1. L’instruction while .................................................................................................................. 38
6.3.2. L’instruction do ....................................................................................................................... 38
6.3.3. L’instruction for ...................................................................................................................... 39
6.3.4. Expression conditionnelle unaire ?......................................................................................... 40
6.4. Du bon choix d‘une boucle ............................................................................................................. 40
7. Compléments ................................................................................................................. 41
8. Fonctions utiles .............................................................................................................. 41
9. Eléments du langage....................................................................................................... 42
9.1. Enumérations................................................................................................................................... 42
9.2. Tableaux .......................................................................................................................................... 42
9.2.1. Déclaration typedef ................................................................................................................ 43
9.2.2. Utilisation des tableaux .......................................................................................................... 44
9.3. Chaînes de caractères ...................................................................................................................... 44
9.3.1. Utilisation des chaînes de caractères ..................................................................................... 45
9.3.2. Quelques fonctions des caractères ........................................................................................ 45
9.4. Pointeurs, références ....................................................................................................................... 45
9.4.1. Adresses ................................................................................................................................. 45
9.4.2. Pointeurs ................................................................................................................................ 46
9.4.3. Références .............................................................................................................................. 47
9.5. Pointeurs et tableaux ....................................................................................................................... 47
9.6. Cas des chaînes de caractères .......................................................................................................... 48
9.7. Gestion de la mémoire — variables dynamiques ............................................................................ 48
10. Spécificités de C++ surlangage de C ........................................................................... 50

10.1. Le commentaire ............................................................................................................................... 50
10.2. Emplacement des déclarations de variables .................................................................................... 50
10.3. Passage de paramètres par référence ............................................................................................... 51
10.4. Arguments par défaut ...................................................................................................................... 52
10.5. Surdéfinition de fonction ................................................................................................................. 52
10.6. Opérateurs new et delete ................................................................................................................. 53
10.7. Spécification « inline » .................................................................................................................... 54
9.7.1. Rappel sur les macros en C ..................................................................................................... 54
9.7.2. Les fonctions inline ................................................................................................................. 54
II. PROGRAMMATION ORIENTEE OBJET ........................................................... 54

1. Classes et objets ............................................................................................................. 54
1.1. Objet ................................................................................................................................................ 55
1.2. Classe .............................................................................................................................................. 55
1.3. Instance ........................................................................................................................................... 55
1.4. Attribut ou membre ......................................................................................................................... 55
1.5. Méthode ou fonction membre ......................................................................................................... 56
1.6. Message ........................................................................................................................................... 56
2. Encapsulation des données ............................................................................................. 56

3. Déclaration et utilisation de classe ................................................................................. 56
3.1. Déclaration de classe ....................................................................................................................... 56
3.2. Définition des fonctions membres de la classe ................................................................................ 57
3.3. Utilisation de la classe ..................................................................................................................... 57
3.4. Membres privés ou publiques .......................................................................................................... 58
3.5. Affectation d‘objets ......................................................................................................................... 58
3.6. Constructeur et destructeur d'objets ................................................................................................ 58
3.6.1. Le constructeur d’objets ......................................................................................................... 58
3.6.2. Le destructeur d’objet ............................................................................................................ 58
4. Régles d'utilisation des fichiers .cpp et .h ....................................................................... 60

5. Membres statiques ......................................................................................................... 61
6. Propriétés des fonctions membres .................................................................................. 61
6.1. Fonctions membres en ligne ............................................................................................................ 61
6.2. Fonctions membres statiques........................................................................................................... 62
6.3. Appel des fonctions membres ......................................................................................................... 62
7. Construction, destruction et initialisation d’objets ......................................................... 64

7.1. Les différents qualificatifs des objets suivant leur type de déclaration ........................................... 64
7.1.1. Les objets automatiques ........................................................................................................ 64
7.1.2. Les objets statiques ................................................................................................................ 64
7.1.3. Les objets dynamiques ........................................................................................................... 64
7.2. Initialisation d'un objet lors de sa déclaration ................................................................................. 65
7.3. Constructeur par recopie ................................................................................................................. 65
7.3.1. Il n’existe pas un constructeur par recopie ............................................................................ 66
7.3.2. Il existe un constructeur par recopie ...................................................................................... 66
7.3.3. Les exceptions ........................................................................................................................ 67
7.3.4. Objets membres ..................................................................................................................... 67
8. Héritage ......................................................................................................................... 67
8.1. 1er aperçu de l'héritage en C++ ....................................................................................................... 67
8.2. Redéfinition de fonctions membre et de membres .......................................................................... 68
8.3. Appel des constructeurs et destructeurs .......................................................................................... 68
8.4. Constructeur par recopie ................................................................................................................. 70
8.5. Contrôle des accès ........................................................................................................................... 70
8.5.1. « private » et « public » .......................................................................................................... 70
8.5.2. « protected » .......................................................................................................................... 70
8.5.3. Mode de dérivation ................................................................................................................ 72
8.6. L'héritage en général ....................................................................................................................... 72
8.7. Exploitation d'une classe dérivée .................................................................................................... 73
8.8. Compatibilité entre objets d'une classe de base et objets d'une classe dérivée ................................ 73
9. Fonctions virtuelles ........................................................................................................ 74

9.1. Les fonctions virtuelles et le typage dynamique ............................................................................. 74
9.2. Le mécanisme d'identification des objets ........................................................................................ 75
9.3. Les fonctions virtuelles en général .................................................................................................. 75
10. Templates ................................................................................................................... 76
10.1. Template de fonctions ..................................................................................................................... 76

10.2. Template de classes ......................................................................................................................... 76
10.3. Généricité et généralisation ............................................................................................................. 77
11. La classe vector de la Standard Template Library ..................................................... 78

12. Surdéfinition d'opérateurs.......................................................................................... 79
12.1. Surcharge de l‘opérateur d‘affectation = ......................................................................................... 79
12.2. Surcharge de l‘opérateur produit * .................................................................................................. 80
12.3. Surcharge d‘opérateurs de flux >> et << ......................................................................................... 81
12.4. Surcharge de l‘opérateur d‘appel (), « fonctions objets » ................................................................ 82
13. Les fonctions amies ..................................................................................................... 83

14. Entrées sorties « élaborées » ....................................................................................... 84
14.1. La classe ios .................................................................................................................................... 84
14.1.1. Les drapeaux de format de ios ............................................................................................... 86
14.1.2. La variable d’état de ios .......................................................................................................... 88
14.2. Les classes istream et ostream ......................................................................................................... 88
14.2.1. Lecture de caractères avec cin.get() ....................................................................................... 88
14.2.2. Fonctions de sortie non formatées ........................................................................................ 90
15. Traitement des fichiers ............................................................................................... 90
III. EXEMPLES DE PROGRAMMATION EN MODE CONSOLE ............................ 92

1. Présentation de l’EDI Dev-C++ ...................................................................................... 92
1.1. Téléchargement de l‘IDE Dev-C++ ................................................................................................ 92
1.2. Installation de l‘IDE Dev-C++ ........................................................................................................ 93
1.3. Etude de l‘interface de l‘IDE Dev-C++........................................................................................... 93
2. Exemple 1- Création d’un projet avec Dev-C++ : « Projet HelloWorl » ......................... 93

2.1. Compilation ..................................................................................................................................... 96
2.2. Exécution......................................................................................................................................... 97
3. Exemple 2- Saisie et somme de deux nombres ................................................................ 97
CONCLUSION............................................................................................................... 98
CHAPITRE III : PROGRAMMATION DES INTERFACES GRAPHIQUES EN C++
AVEC Qt ........................................................................................................................ 99
INTRODUCTION .........................................................................................................100
1. Création d’un projet .....................................................................................................100
2. Structure d’un projet ....................................................................................................102
2.1. Le fichier main.cpp ....................................................................................................................... 102
2.2. Les fichiers mainwindow.cpp et mainwindow.h ........................................................................... 102
3. Le générateur d’interface : Exemple 1-Ajout d’un bouton ............................................102

3.1. Création d‘un bouton « Quitter » .................................................................................................. 103
3.2. Ecriture du code de fonctionnement pour le clic sur le bouton ..................................................... 104
3.3. Test : Compilation et exécution..................................................................................................... 105
4. Composition du dossier du travail .................................................................................106
5. Afficher des messages dans la fenêtre ............................................................................107

6. Utilisation d’une barre de progression. .........................................................................109
CONCLUSION..............................................................................................................111
CONCLUSION GENERALE .........................................................................................112
QUESTIONNAIRE AUX CHOIX MULTIPLES (QCM) ................................................113
QUESTIONS-REPONSES ............................................................................................114
EXERCICES .................................................................................................................115
CORRIGES PROPOSES DES EXERCICES .................................................................119
GLOSSAIRE .................................................................................................................127
BIBLIOGRAPHIE ET WEBOGRAPHIE ......................................................................131
INTRODUCTION GENERALE
Concevoir et développer un logiciel ou une application nécessite la maîtrise d‘un langage
de programmation parmi lesquels l‘on peut citer le langage de programmation C++ qui est un
langage de programmation procédurale et orientée-objet.
C++ est un langage de programmation compilé permettant la programmation sous de
multiples paradigmes (comme la programmation procédurale, orientée objet ou générique).
Ses bonnes performances, et sa compatibilité avec le C en font un des langages de
programmation les plus utilisés dans les applications où la performance est critique. Créé
initialement par Bjarne Stroustrup dans les années 1980, le langage C++ est
aujourd'hui normalisé par l'ISO. Sa première normalisation date de 1998 (ISO/CEI
14882:1998), ensuite amendée par l'erratum technique de 2003 (ISO/CEI 14882:2003). Une
importante mise à jour a été ratifiée et publiée par l'ISO en septembre 2011 sous le nom de
ISO/IEC 14882:2011, ou C++11 Depuis, des mises à jour sont publiées régulièrement : en
2014 (ISO/CEI 14882:2014, ou C++14) puis en 2017 (ISO/CEI 14882:2017, ou C++17).
Ce livre est constitué de trois (3) chapitres. Le premier chapitre intitulé
« PRESENTATION GENERALE DU LANGAGE C++ ET DU PARADIGME P.O.O. »
présente de manière générale le langage C++, son origine et ses évolutions dans sa première
section. La deuxième section aborde le paradigme Orienté Objet (OO). Le deuxième chapitre
intitulé « LES BASES DU LANGAGE C++ ET LA PROGRAMMATION EN MODE
CONSOLE » présente dans la première section tous les concepts de base du langage c++.
Dans la deuxième section, le livre aborde les concepts de la programmation orientée objet
(POO). Dans la troisième section, le livre présente des exemples de création de projets en
mode console. Le troisième chapitre intitulé «PROGRAMMATION DES INTERFACES
GRAPHIQUES EN C++ AVEC Qt » présente la réalisation des applications graphiques en
C++ avec le framework QtCreator de l‘IDE Qt.
En plus des trois chapitres évoqués, le livre comporte également des exercices et corrigés
et un lexique dans le domaine des TIC en général et en particuliers dans les langages de
programmation.
CHAPITRE I : PRESENTATION GENERALE DU LANGAGE C++

ET DU PARADIGME P.O.O.
INTRODUCTION
Ce premier chapitre va discuter des généralités et des concepts généraux du langage de
programmation C++. Les caractéristiques du langage C++ sera également présenté dans ledit
chapitre.
1. Qu‘est-ce qu‘un langage ?
Un langage est une faculté de mettre en oeuvre un système de signes permettant la
communication et l'expression de la pensée ou c‘est un ensemble de systèmes d'instructions et
de règles syntaxiques servant à produire des effets prévisibles et de permettre leur
manipulation automatisée.
1.1.Caractéristiques d‘un langage
1.1.1. Expressivité
Un langage doit exprimer la solution dans les termes du problème à résoudre plutôt que
ceux de l'ordinateur sur lequel on code. Un langage peut être très expressif dans certains
domaines et pas dans d'autres. Un langage doit également faciliter la maintenance et
l'évolution du produit.
1.1.2. Simplicité
Un langage doit parvenir à éviter la complexité ou à la gérer correctement. Pas plusieurs
manières de faire les choses.
1.1.3. Implémentation
Un langage doit permettre les points suivants :
 Facilité avec laquelle le langage peut être traduit,
 Efficacité du code résultant,
 Interprétation ou compilation.
1.1.4. Puissance
La puissance d‘un langage se mesure par les différentes possibilités d'actions et le
périmètre d'action.
1.2.Historique générale des langages
Le tableau ci-dessous présente l‘historique de différents langages informatiques.
Tableau 1.1 : Historique des langages informatiques
Prise en Applis Applis
Nom Date Type Paradigmes Lisibilité
main Web GUI
Fortran 1954 Compilé Impératif Moyenne Bonne Possible Non
Cobol 1959 Compilé Impératif Moyenne Moyenne Possible Non
C 1973 Compilé Impératif Longue Moyenne Possible Oui
Impératif,
C++ 1982 Compilé Longue Moyenne Oui Oui
objet
Compilé
Java 1995 Objet Longue Moyenne Oui Oui
(byte code)
C# 2002 Compile Impératif, Longue Moyenne Oui Oui
(byte code) objet

Impératif,
PHP 1994 Interprété rapide Moyenne Oui Oui
objet
Impératif,
JavaScript 1995 Interprété Rapide Moyenne Oui Oui
objet
Impératif,
Perl 1987 Interprété Rapide Moyenne Oui Oui
objet
Impératif,
Python 1991 Interprété Rapide Bonne Oui Oui
objet
Ruby 1993 Interprété Objet Rapide Bonne Oui Oui
Impératif, Possible
VB 1991 Compilé Rapide Bonne Oui
objet via .NET
Impératif, Possible
Delphi 1995 Compilé Moyenne Moyenne Oui
objet via .NET
1.3.Evolutions des langages

L‘évolution des langages informatiques est illustrée par la figure ci-dessous.
Figure 1.1: Evolution des langages informatiques (Source : http ://www.tiobe.com/)
1.4.Langages objets
La notion du paradigme « objet » a vu le jour dans les années 1960.
60 : Apparition d'un concept de classe dans Simula-67 (Record Class),
70 : Ajout des concepts objets dans Smalltalk 71 (Alan Kay),
80 : Objective C, C++, Eiffel et Common Lisp Obj. System,
90 : Python, Java, Ruby,
2000 : C#, D, ...
Le paradigme objet est toujours d'actualité. On considère que sa définition s'est stabilisée
au milieu des années 90.
2. Dénomination
En langage C, ++ est l'opérateur d'incrémentation, c'est-à-dire l'augmentation de la valeur
d'une variable de 1. C'est pourquoi C++ porte ce nom : cela signifie que C++ est un niveau
au-dessus de C. Il existe de nombreuses bibliothèques C++ en plus de la bibliothèque standard
du C++ (C++ Standard Library) qui est incluse dans la norme. Par ailleurs, C++ permet
l'utilisation de l'ensemble des bibliothèques C existantes.
3. Histoire
Bjarne Stroustrup a développé C++ au cours des années 1980, alors qu'il travaillait dans
le laboratoire de recherche Bell d'AT&T. L'idée de créer un nouveau langage venait de
l'expérience en programmation de Stroustrup pour sa thèse de doctorat. Il s'agissait en
l'occurrence d'améliorer le langage C. Il l'avait d'ailleurs nommé C with classes (« C avec des
classes »). Stroustrup trouvait que Simula avait des fonctionnalités très utiles pour le
développement de gros programmes mais qu'il était trop lent pour être utilisé en pratique (cela
était dû à un problème d'implémentation du compilateur Simula), tandis que BCPL était
rapide mais de trop bas niveau et non adapté au développement de gros logiciels. Quand
Stroustrup commença à travailler aux laboratoires Bell, on lui demanda d'analyser
le noyau UNIX en vue de faire du calcul distribué. Se rappelant sa thèse, Stroustrup
commença à améliorer le langage Cavec des fonctionnalités similaires à celle de Simula. C fut
choisi parce qu'il est rapide, portable et d'usage général. En outre, il était une bonne base pour
le principe original et fondateur de C++ : « vous ne payez pas pour ce que vous n'utilisez
pas ». Dès le départ, le langage ajoutait à C la notion de classe (avec encapsulation des
données), de classe dérivée, de vérification des types renforcés (typage fort), d'« inlining », et
d'argument par défaut.
Alors que Stroustrup développait C with classes, il écrivit CFront, un compilateur qui
générait du code source C à partir de code source C with classes. La première
commercialisation se fit en octobre 1985. En 1983, le nom du langage passa de C with
classes à celui de « C++ ». Parmi les nouvelles fonctionnalités qui furent ajoutées au langage,
il y avait les fonctions virtuelles, la surcharge des opérateurs et des fonctions, les références,
les constantes, le contrôle du typage amélioré et les commentaires en fin de ligne. En 1985 fut
publiée la première édition de The C++ Programming Language, apportant ainsi une
référence importante au langage qui n'avait pas encore de standard officiel. En 1989, c'est la
sortie de la version 2.0 de C++. Parmi les nouvelles fonctionnalités, il y avait l'héritage
multiple, les classes abstraites, les fonctions membres statiques, les fonctions membres
constantes, et les membres protégés. En 1990, The Annotated C++ Reference
Manual (« ARM ») fut publié apportant les bases du futur standard. Les ajouts de
fonctionnalités tardifs qu'il comportait couvraient les templates, les exceptions, les espaces de
noms, les nouvelles conversions et le type booléen.
Pendant l'évolution du langage C++, la bibliothèque standard évoluait de concert. Le
premier ajout à la bibliothèque standard du C++ concernait les flux d'entrées/sorties qui
apportaient les fonctionnalités nécessaires au remplacement des fonctions C traditionnelles
telles que printf et scanf. Ensuite, parmi les ajouts les plus importants, il y avait la Standard
Template Library. Après des années de travail, un comité réunissant l'ANSI et
l'ISO standardisa C++ en 1998 (ISO/CEI 14882:1998), l'année où le comité de standardisation
se réunissait à Sophia Antipolis dans le sud de la France. Pendant quelques années après la
sortie officielle du standard, le comité traita des problèmes remontés par les utilisateurs, et
publia en 2003 une version corrigée du standard C++.
Personne ne possède le langage C++. Il est libre de droits ; cependant, le document de
standardisation n'est quant à lui pas disponible gratuitement.
La figure ci-dessous présente l‘inventeur du langage C++.
Figure 1.2 : Bjarne Stroustrup, l'inventeur du C++.

4. Fonctionnalités introduites
On peut considérer que C++ « est du C » avec un ajout de fonctionnalités. Cependant,
certains programmes syntaxiquement corrects en C ne le sont pas en C++, à commencer bien
sûr par ceux qui font usage d'identificateurs correspondant à des mots-clefs en C++.
Les fonctionnalités ajoutées sont :
 le typage des « prototypes » de fonctions (repris dans ANSI C89),
 les déclarations reconnues comme instructions (repris dans C99),
 les opérateurs new et delete pour la gestion d'allocation mémoire,
 le type de données bool (booléen),
 les références &,
 les variables et les fonctions const (repris par C à la fin des années 1980),
 les fonctions inline (repris dans C99),
 les paramètres par défaut dans les fonctions,
 les référentiels lexicaux (espaces de noms) et l'opérateur de résolution de portée ::,
 les classes, ainsi que tout ce qui y est lié : l'héritage, les fonctions membres, les
fonctions membres virtuelles, les constructeurs et le destructeur,
 la surcharge des opérateurs,
 les templates,
 la gestion d'exceptions,
 l'identification de type pendant l'exécution (RTTI : run-time type information),
 le commentaire sur une ligne introduit par // (existant dans BCPL, repris dans C99),
 l'inférence de type auto (C++11),
 les références de rvalue && (C++11),
 les fonctions lambda (C++11).

La compilation d'un programme en C++ effectue également un contrôle plus minutieux
du typage.
5. Bibliothèque standard
La bibliothèque standard du C++ est en grande partie un sur-ensemble des fonctions
disponibles dans la bibliothèque standard du C. Elle englobe la Standard Template
Library (STL) qui met à la disposition du programmeur des outils puissants comme les
collections (conteneurs) et les itérateurs.
À l'origine, la STL était une bibliothèque développée par Alexander Stepanov qui
travaillait pour Hewlett-Packard. Dans la norme, celle-ci n'est pas appelée STL, car elle est
considérée comme faisant partie de la bibliothèque standard du C++. Toutefois, beaucoup de
personnes l'appellent encore de cette manière pour distinguer d'une part, les fonctions
d'entrées/sorties comprises dans cette bibliothèque et, d'autre part, celles fournies par la
bibliothèque C.
Comme en C, l'utilisation d'une bibliothèque se fait par l'intermédiaire de la
directive #include (suivie du nom du fichier d'en-tête), et certaines d'entre elles
(cmath, thread, etc.) nécessitent d'être liées explicitement.
6. Programmation orientée objet
Le langage C++ utilise les concepts de la programmation orientée objet et permet entre
autres :
 la classification (classes),
 l'encapsulation,
 des relations entre les classes :
 la composition de classes (composition dans un diagramme de classes),

 l'association de classes (association dans un diagramme de classes),
 l'agrégation de classes (agrégation dans un diagramme de classes),
 la dépendance (dépendance dans un diagramme de classes),
 l'héritage simple et multiple (héritage dans un diagramme de classes),
 le polymorphisme,
 l'abstraction,
 la généricité,
 la méta-programmation.
6.1.Encapsulation
L'encapsulation permet de faire abstraction du fonctionnement interne (c'est-à-dire, la
mise en œuvre) d'une classe et ainsi de ne se préoccuper que des services rendus par celle-ci.
C++ met en œuvre l'encapsulation en permettant de déclarer les membres d'une classe avec le
mot réservé public, private ou protected. Ainsi, lorsqu'un membre est déclaré :
 public, il sera accessible depuis n'importe quelle fonction ;
 private, il sera uniquement accessible d'une part, depuis les fonctions qui sont membres
de la classe et, d'autre part, depuis les fonctions autorisées explicitement par la classe
(par l'intermédiaire du mot réservé friend) ;
 protected, il aura les mêmes restrictions que s'il était déclaré private, mais il sera en
revanche accessible par les classes filles.
C++ n'impose pas l'encapsulation des membres dans leurs classes. On pourrait donc
déclarer tous les membres publics, mais en perdant une partie des bénéfices apportés par la
programmation orientée objet. Il est de bon usage de déclarer toutes les données privées, ou
au moins protégées, et de rendre publiques les méthodes agissant sur ces données. Ceci
permet de cacher les détails de la mise en œuvre de la classe.
6.1.1. « Hello, world »
Voici l'exemple de Hello world donné dans The C++ Programming Language, Third
Edition de Bjarne Stroustrup :
#include<iostream>
int main()
{
std::cout << "Hello, new world!\n";
}
Dans l'exemple ci-dessus, le code source std::cout << "Hello, new world!\n" envoie la
chaîne de caractères "Hello, new world!\n" à l'objet global cout, défini dans l'espace de noms
standard std, grâce à l'opérateur << de l'objet cout.
6.1.2. Espace de noms
En C++, le mot clef namespace permet de définir et de nommer des espaces de
noms (namespaces), notion déjà présente en langage C ; en effet, le corps d'une routine,
d'une structure de contrôle de flux d'exécution, d'une structure de données ou d'une section de
code (délimitée par les accolades { et }) constitue un espace de noms. En C++, le corps d'une
classe, à l'instar du corps d'une structure de données, constitue aussi un espace de noms.
Dans différents espaces de noms, on peut ainsi définir des entités (routines, variables,
etc.) ayant le même identificateur. L'ambiguïté est résolue en utilisant le nom de l'espace de
nom devant l'opérateur de portée (::) pour indiquer l'espace de noms dans lequel on veut
accéder. Notez que l'espace de noms global du programme n'a pas de nom. Pour accéder à une
entité globale, cachée par une entité locale par exemple, on utilise l'opérateur de portée
précédé d'aucun nom.
6.1.3. Directive using
Il est possible de spécifier un espace de noms précis à utiliser afin d'éviter d'avoir à
recourir à l'opérateur de résolution de portée. Pour cela, le mot-clé using est utilisé avec cette
syntaxe :
using namespace nom_du_namespace;
// ou
using nom_d_un_symbole;
Ainsi, pour utiliser la variable cout définie dans le namespace standard sans utiliser
l'opérateur de résolution de portée, il est possible d'écrire using namespace std; ou using
std::cout;. Cela est valable pour tous les espaces de noms. Cette instruction se place en
général avant le début du code source proprement dit :
#include<iostream>
using namespace std;
int main()
{
cout << "Hello, new world!" << endl;
}
Il est aussi possible, et conseillé, d'importer un symbole particulier, ou de placer cette
instruction dans une fonction afin de limiter la portée :
#include<iostream>
int main()
{
using std::cout;
cout << "Hello, new world!" // std::cout est disponible sans utilisation de std::
<< std::endl; // mais pas std::endl
}
void foo(){
std::cout << "Hello, new world!" ;
// std::cout n'est plus disponible sans utilisation de std:: << std::endl;
}
Le mot-clé using peut aussi être utilisé dans les classes. Si une classe B hérite d'une
classe A, elle peut grâce à ce mot-clé passer des membres protected de A en public dans B,
ou encore démasquer une fonction membre de A qui le serait par une fonction membre de B
de même nom :
#include <cstdlib> //## EXIT_SUCCESS
#include <iostream> //## cout
using namespace std; //## cout
//** ************************************************************
//! Déclaration de la classe de base A.
class A{
protected:
void f();
public:
void g();
};
//** ============================================
//! Définition de la méthode A::f()
void A::f(){
cout << "Methode A::f()\n";
}
//** ============================================
//! Définition de la méthode A::g()
void A::g(){
cout << "Methode A::g()\n";
}
//** ************************************************************
//! Déclaration de la classe B hérité de A.
class B: public A{
public:
using A::f; // rend public A::f()
};
//** ************************************************************
//! Déclaration de la classe C hérité de A.
class C: public A{
public:
void g(int Val); // masque A::g()
};
//** ============================================
//! Définition de la méthode C::g(int Val)
void C::g(int Val){
cout << "Methode C::g()\n";
}
//** ************************************************************
//! Déclaration de la classe D héritée de A.
class D: public A{
public:
void g(int Val); // masque A::g()
using A::g; // démasque A::g()
};
//** ============================================
//! Définition de la méthode D::g(int Val)
void D::g(int Val){
cout << "Methode D::g(int)\n";
}
//** ************************************************************
int main(){
//! Définition des objets.
A a; B b; C c; D d;
#if 0
a.f(); // impossible car f est protégée dans A
#endif
a.g();
b.f(); // possible car A::f est publique dans B.

#if 0
c.g(); // impossible car A::g() est masquée par C::g(int) dans C
#endif
c.g(6); // possible car C::g(int Val) est masquée par C::g(int) dans C
d.g(); // possible car A::g() est démasquée dans D
d.g(5); // possible car D::g() est démasquée dans D
return EXIT_SUCCESS;
}
Le programme ci-dessus affiche :

Methode A::g()
Methode A::f()
Methode C::g()
Methode A::g()
Methode D::g(int)
Il est aussi possible de définir un nouveau nom pour un namespace :

namespace po = boost::program_options;
// on peut alors écrire po::option au lieu de boost::program_options::option
6.2.Déclaration et définition de classe
Il est d'usage de séparer prototype (déclaration) et implémentation (définition) de classe
dans deux fichiers : la déclaration se fait dans un fichier d'en-tête (dont l'extension varie selon
les préférences des développeurs : sans extension dans le standard, .h comme en C, .hh ou
.hpp ou .hxx pour différencier le code source C++ du C) alors que la définition se fait dans un
fichier source (d'extension également variable : .c comme en C, .cc ou .cpp ou .cxx pour
différencier le C++ du C).
6.2.1. Déclaration de classe
Exemple de la déclaration d'une classe comportant des attributs privés et
des méthodes publiques :
// messageinternet.hpp
#include<string>
class MessageInternet{
private:
const std::string m_sujet, m_expediteur, m_destinataire; // attributs
public:
MessageInternet(
const std::string& sujet,
const std::string& expediteur,
const std::string& destinataire); // constructeur
~MessageInternet(); // destructeur
const std::string& get_sujet() const; // méthode
const std::string& get_expediteur() const; // méthode
const std::string& get_destinataire() const; // méthode
};
6.2.2. Définition de classe

Le nom d'une méthode déclarée par une classe doit nécessairement être précédé du nom
de la classe suivi de l'opérateur de résolution de portée ::.
Exemple de définition des méthodes d'une classe (celle déclarée précédemment) :
// messageinternet.cpp
#include "messageinternet.hpp"
// constructeur
MessageInternet::MessageInternet(
const std::string& sujet,
const std::string& expediteur,
const std::string& destinataire):
m_sujet(sujet), m_expediteur(expediteur), m_destinataire(destinataire)
{
}
// destructeur (pour libérer les ressources acquises ; dans notre cas il n'y a rien à faire)
MessageInternet::~MessageInternet()
{
}
const std::string& MessageInternet::get_sujet() const
{
return m_sujet;
}
const std::string& MessageInternet::get_expediteur() const
{
return m_expediteur;
}
const std::string& MessageInternet::get_destinataire() const
{
return m_destinataire;
}
6.3.Templates
Les templates permettent d'écrire des fonctions et des classes en paramétrant le type de
certains de leurs constituants (type des paramètres ou type de retour pour une fonction, type
des éléments pour une classe collection par exemple). Les templates permettent d'écrire du
code générique, c'est-à-dire qui peut servir pour une famille de fonctions ou de classes qui ne
diffèrent que par le type de leurs constituants.
6.3.1. Paramètres des templates
Les paramètres peuvent être de différentes sortes :
 types simples, tels que les classes ou les types élémentaires (int, float, etc.),
 tableaux de taille constante, dont la taille, déduite par le compilateur, peut être utilisée
dans l'instanciation du Template,
 constantes scalaires, c'est-à-dire de type entier (int, char, bool), mais pas flottant
(float, double) car leur représentation binaire ne fait pas partie de la norme du langage,
 templates, dont la définition doit être passée en paramètre, ce qui permet notamment de
s'appuyer sur la définition abstraite, par exemple, d'une collection,
 pointeurs ou références, à condition que leur valeur soit définie à l'édition de liens,
 méthode d'une classe, dont la signature et la classe doivent être aussi passées en
paramètres,
 attribut d'une classe, dont le type et la classe doivent être aussi passés en paramètres.
6.3.2. Utilité des templates
En programmation, il faut parfois écrire de nombreuses versions d'une même fonction ou
classe suivant les types de données manipulées. Par exemple, un tableau de int ou un tableau
de double sont très semblables, et les fonctions de tri ou de recherche dans ces tableaux sont
identiques, la seule différence étant le type des données manipulées. En résumé, l'utilisation
des templates permet de « paramétrer » le type des données manipulées.
Les avantages des templates sont :
 des écritures uniques pour les fonctions et les classes,
 moins d'erreurs dues à la réécriture.
6.3.3. Exemple de templates
Dans la bibliothèque standard C++, on trouve de nombreux templates. On citera à titre
d'exemple, les entrées/sorties, les chaînes de caractères ou les conteneurs. Les
classes string, istream, ostream et iostream sont toutes des instanciations de type char.
Les fonctions de recherche et de tri sont aussi des templates écrits et utilisables avec de
nombreux types.
#include<string>
// fonction pouvant être appelée avec tous types copiables et ordonnés par l'opérateur <
template<typename T>
T max(T a, T b)
{
return a < b? b: a;
}
int main(){
int i = max(3, 5);
char c = max('e', 'b');
std::string s = max(std::string("hello"), std::string("world"));
float f = max<float>(1, 2.2f); // type paramétré donné explicitement (obligatoire avec ces
paramètres de types différents)
}
Dans la ligne float f = max<float>(1, 2.2f);, on doit explicitement donner le
type float pour le type paramétré T car le compilateur ne déduit pas le type de Tlorsqu'on
passe en même temps un int (1) et un float (2.2f).
6.3.4. Spécialisation des templates
Un template donné peut avoir plusieurs instanciations possibles selon les types donnés en
paramètres. Si un seul paramètre est spécialisé, on parle de spécialisation partielle. Ceci
permet par exemple :
 de choisir un type de calcul selon qu'un type est un entier, un flottant, une chaîne de
caractères, etc. Spécialisons l'exemple précédent pour le cas des pointeurs de chaînes de
caractères :
template<>
const char* max(const char* a, const char* b)
{
return strcmp(a, b) > 0? a: b;
}
 d'effectuer au moment de la compilation des calculs arithmétiques, si et seulement si

tous les arguments sont connus à ce moment. Un exemple classique est le calcul de la
fonction factorielle :
template<size_t N>
struct CalcCompileTime
{
static const size_t Fact = N * CalcCompileTime<N - 1>::Fact;
};
template<>
struct CalcCompileTime<0>
{
static const size_t Fact = 1;
};
6.3.5. SFINAE
Le mécanisme décrit par l'abréviation SFINAE (Substitution Failure Is Not an Error)
permet de surcharger un template par plusieurs classes (ou fonctions), même si certaines
spécialisations, par exemple, ne peuvent pas être utilisées pour tous les paramètres de
templates. Le compilateur, lors de la substitution, ignore alors les instanciations inapplicables,
au lieu d'émettre une erreur de compilation.
6.4.Polymorphisme et méthodes virtuelles
Le polymorphisme d'inclusion est mis en œuvre à l'aide du mécanisme des méthodes
virtuelles en C++. Une méthode est rendue virtuelle par le placement du mot-
clé virtual devant la déclaration de la méthode dans la classe. Lorsqu'une méthode virtuelle
est appelée, l'implémentation de la méthode exécutée est choisie en fonction du type réel de
l'objet. L'appel n'est donc résolu qu'à l'exécution, le type de l'objet ne pouvant pas a priori être
connu à la compilation.
Le mot-clé virtual indique au compilateur que la méthode déclarée virtuelle est
susceptible d'être redéfinie dans une classe dérivée. Il suffit alors de dériver une classe et de
définir une nouvelle méthode de même signature (même nom, paramètres compatibles — voir
la notion de covariance). Ainsi l'appel de cette méthode sur un objet accédé en tant qu'objet de
la classe de base mais appartenant en réalité à la classe dérivée donnera lieu à l'appel de la
méthode définie dans la classe dérivée.
En particulier, il est obligatoire d'utiliser le mot-clé virtual devant la déclaration du
destructeur de la classe de base lorsque le programme souhaite pouvoir détruire un objet via
un pointeur d'instance de la classe de base au lieu d'un pointeur d'instance de la classe dérivée.
Ce type de polymorphisme (le polymorphisme d'inclusion) est dit dynamique. Le
mécanisme de la surcharge qui est un polymorphisme ad hoc est de type statique. Dans les
deux cas il faut appliquer une logique (par exemple : le nombre et le type des paramètres)
pour résoudre l'appel. Dans le cas de la surcharge, la logique peut être entièrement calculée à
la compilation. Ce calcul permet des optimisations rendant le polymorphisme statique plus
rapide que sa version dynamique. La liaison dynamique de méthodes issues du mécanisme
des méthodes virtuelles induit souvent une table cachée de résolution des appels, la table
virtuelle. Cette table virtuelle augmente le temps nécessaire à l'appel de méthode à l'exécution
par l'ajout d'une indirection supplémentaire.
Le choix entre liaison dynamique et surcharge (polymorphisme dynamique et statique)
est typiquement un problème de calculabilité des appels, ayant souvent pour conséquence
finale un choix entre expressivité et performance.
7. Outils de développement
Un programme C++ peut être produit avec des outils qui automatisent le processus de
construction. Les plus utilisés sont :
 make,
 Ant (génération portable en XML),
 SCons (génération portable en Python),
 CMake (génération de Makefile portable).
8. Environnements de développement
Les environnements de développement C++ ou IDE (Integrated Development
Environnement) ou Environnement de Développement Intégré (EDI) sont entre autres :
 Anjuta DevStudio,
 C++ Builder,
 CLion (en),
 Code::Blocks (open-source),
 Dev-C++ et son extension RAD WxDev-C++,
 Eclipse avec le plugin CDT (open-source),
 Emacs (libre),
 KDevelop,
 NetBeans (open-source),
 QtCreator (open-source),
 Sun Studio,
 Vim,
 Microsoft Visual C++,
 Xcode.
Les environnements de développement utilisés dans ce livre sont le Dev-C++ pour la
programmation en mode console et le QtCreator pour la programmation des interfaces
graphiques.
9. Compilateurs
Le langage C++ dispose de plusieurs compilateurs à savoir :
 GCC pour GNU Compiler Collection (libre, multilangage et multiplateforme : UNIX,

Windows, DOS, etc.),
 Clang,
 Microsoft Visual C++ (Windows),
 Borland C++ Builder (Windows),
 Intel C++ Compiler (Windows, Linux, MacOS),
 Open64 (en) compilateur opensource d'AMD (Linux),
 Digital Mars C/C++ compiler (Windows),
 Comeau C++ Compiler,
 Open Watcom.
Il sera utilisé dans ce livre, le compilateur GCC pour la compilateur de nos programmes
C++.
10. Bibliothèques
Parmi les bibliothèques existantes de C++, l‘on peut citer les bibliothèques suivantes :
 Boost,
 Qt,
 Gtkmm,
 wxWidgets,
 SFML,
 OpenCV,
 SDLmm, surcouche C++ à la SDL,
 LLVM.
Il sera utilisé dans ce livre, la bibliothèque Qt pour la création des interfaces graphiques.
CONCLUSION
Ce premier chapitre a discuté de manière générale le langage de programmation C++ en
présentant son origine, son historique et ses différentes versions. Le chapitre II se focalisera
sur les bases et la programmation en mode console du langage C++.
CHAPITRE II : LES BASES DU LANGAGE C++ ET LA

PROGRAMMATION EN MODE CONSOLE
INTRODUCTION
Ce chapitre présentera les bases du langage C++. Il sera en effet question dans la
première section de ce chapitre de présenter les différentes syntaxes à savoir la notion de
variables, les types de variables, les mots clés, notion de classes, de méthodes, la syntaxe de
déclarations, les structures conditionnelles, les boucles, etc. Dans la dernière section,
l‘apprenant se familiarisera avec la programmation en mode console. La programmation des
interfaces graphiques sera présentée dans le troisième chapitre du livre. Les outils de
développement utilisés dans ce livre sont : Dev-C++ et le QtCreator.
I. CONCEPTS DE BASE DU LANGAGE C++
1. Mots réservés en C++
Les mots réservés en Java sont entre autres :
Include, define, bool, else, static, friend, operator, try, bool, false, interface, byte, true,
break, while, char, case, new, delete, switch, double, catch, finally, float, class, for,
private, this, int, const, goto, protected, long, continue, if, public, short, default, return,
void, null, do, inline, string, typedef , template, virtual.
Note : Il est interdit d‘utiliser les mots réservés comme identificateurs de variables,
méthodes ou fonctions, fonctions, etc.
2. Variables
2.1.Terminologie
Une variable est caractérisée par :
 son nom : mot composé de lettres ou chiffres, commençant par une lettre (le caractère
tient lieu de lettre),
 son type précisant la nature de cette variable (nombre entier, caractère, objet etc.),
 sa valeur qui peut être modifiée à tout instant.
Durant l‘exécution d‘un programme, à toute variable est attachée une adresse : nombre
entier qui indique où se trouve stockée en mémoire la valeur de cette variable.
2.2.Types de base
2.2.1. Vide
void : Aucune variable ne peut être de ce type. Nous en verrons l‘usage dans les sections
suivantes avec la définition des fonctions.
2.2.2. Entiers
Le type entier par taille-mémoire croissante est le suivant:
 Char : Ce type est stocké sur un octet ; valeurs : de −27 à 27 − 1 (−128 à 127),
 short: Il est stocké sur 2 octets ; valeurs : de −215 à 215 − 1 (−32768 à 32767),
 long : Il est stocké sur 4 octets ; valeurs : de −231 à 231 − 1,
 int : Ce type de variable coïncide avec short ou long, selon l‘installation.
2.2.3. Réels
Le type réel par taille-mémoire croissante est le suivant:
 Float : Ce type est stocké sur 4 octets ; précision : environ 7 chiffres,
 double: Ce type est stocké sur 8 octets ; précision : environ 15 chiffres,
 long double est stocké sur 10 octets ; précision : environ 18 chiffres.
On trouve parfois le mot unsigned précédant le nom d‘un type entier (on parle alors
d‘entier non signé ; un tel entier est toujours positif).
2.2.4. Booléens
 Bool : Une valeur parmi deux possibles, vrai (true) ou faux (false).
2.2.5. Chaînes de caractères
 String : Une chaîne de caractères, c'est-à-dire un mot ou une phrase.

Note : Char est un type caractères représenté sur 8 bits.
2.3.Valeurs littérales (ou explicites)
2.3.1. Caractères
Il s‘agit des caractères usuels entre apostrophes, correspondant à des entiers de type char.
Par exemple : ‘A‘ (= 65), ‘a‘ (= 97), ‘0‘ (= 48), ‘ ‘ (= 32). La correspondance caractères
usuels <-> entiers de type char est donnée par la table des codes ASCII.
A connaître les caractères spéciaux suivants :
 ‘\n‘ : retour à la ligne,
 ‘\t‘ : tabulation.
2.3.2. Chaînes de caractères
Les chaînes de caractères sont placées entre guillemets, pour les affichages.
Par exemple : "Au revoir!\n".
On reviendra plus tard sur le type chaîne de caractères.
2.3.3. Valeurs entières
Les valeurs entières, par exemple : 123, -25000, 133000000 (ici respectivement de type
char, short, long).
2.3.4. Valeurs réelles
Les valeurs réelles comportent une virgule, par exemple : 3.14, -1.0, 4.21E2 (signifiant
4,21 102).
2.4.Déclaration des variables
En C++, toute variable doit être déclarée avant d‘être utilisée.
Forme générale d‘une déclaration :
<type> <liste de variables>;
où :
<type> est un nom de type ou de classe,
<liste de variables> est un ou plusieurs noms de variables, s´éparés par des virgules.
Exemples :
int i, j, k; // déclare trois entiers i, j, k
float x, y; // déclare deux réels x, y
2.5.Déclaration + initialisation
En même temps qu‘on déclare une variable, il est possible de lui attribuer une valeur
initiale. On pourra écrire par exemple :
int i, j = 0, k;
float x, y = 1.0;
En particulier, on peut déclarer une constante en ajoutant const devant le nom du type,
par exemple :
const double PI = 3.14159265358979323846;
const int MAX = 100;
Les valeurs des constantes ne peuvent pas être modifiées.
3. Expressions
3.1.Définition
En combinant des noms de variables, des opérateurs, des parenthèses et des appels de
fonctions, on obtient des expressions.
Une règle simple à retenir :
En C++, on appelle expression tout ce qui a une valeur.
3.2.Opérateurs arithmétiques
+ : addition,
- : soustraction,
* : multiplication,
/ : division. Attention : entre deux entiers, donne le quotient entier,
% : entre deux entiers, donne le reste modulo.
Exemples :
19.0 / 5.0 vaut 3.8,
19 / 5 vaut 3,
19 % 5 vaut 4.
Dans les expressions, les règles de priorité sont les règles usuelles des mathématiciens.
Par exemple, l‘expression 5 + 3 * 2 a pour valeur 11 et non 16. En cas de doute, il ne faut pas
hésiter à mettre des parenthèses.
Incrémentation et décrémentation
++ : Incrémentation. Si i est de type entier, les expressions i++ et ++i ont toutes deux
pour valeur la valeur de i. Mais elles ont également un effet de bord qui est :
– pour la première, d‘ajouter ensuite 1 à la valeur de i (post-incrémentations),

– pour la seconde, d‘ajouter d‘abord 1 à la valeur de i (pré-incrémentations).
-- : décrémentation. i-- et --i fonctionnent comme i++ et ++i, mais retranchent 1 à la
valeur de i au lieu d‘ajouter 1.
3.3.Opérateurs d‘affectation
2.5.1. Egal (=)
Forme générale de l‘expression d‘affectation :
<variable> = <expression>;
Fonctionnement :
 l‘<expression> est d‘abord évaluée ; cette valeur donne la valeur de l‘expression
d‘affectation,
 effet de bord : la <variable> reçoit ensuite cette valeur.
Exemples :
i=1
i = j = k = 1 (vaut 1 et donne à i, j et k la valeur 1)
2.5.2. Les opérateurs composites

+=, -=, *=, /=, %=
Forme générale :
<variable> <opérateur>= < expression> ;
L‘expression est équivalente à :

<variable> = <variable> <opérateur> <expression> ;
Par exemple, l‘expression i += 3 équivaut à i = i + 3.

3.4.Conversion de type
L‘expression d‘affectation peut provoquer une conversion de type. Par exemple,
supposons déclarés :
int i;
float x;
Alors, si i vaut 3, l‘expression x = i donne à x la valeur 3.0 (conversion entier → réel).

Inversement, si
x vaut 4.21, l‘expression i = x donne à i la valeur 4, partie entière de x (conversion réel →
entier).
On peut également provoquer une conversion de type grâce à l‘opérateur () (type casting).
Avec x comme ci-dessus, l‘expression (int)x est de type int et sa valeur est la partie entière de
x.
3.5.Opérateurs d‘entrées-sorties
Ce sont les opérateurs << et >>, utilisés en conjonction avec des objets prédéfinis cout et
cin déclarés dans <iostream.h> (ne pas oublier la directive #include <iostream.h> en début de
fichier).
Forme :
cout << <expression> : affichage à l‟écran de la valeur de <expression>,
cin >> <variable> : lecture au clavier de la valeur de <variable>
3.6.Formatage des sorties numériques

On peut modifier l‘apparence des sorties grâce aux expressions suivantes :
Endl : provoque un passage à la ligne
setfill(c) : fixe le caractère de remplissage (si ce n‟est pas un blanc)
setprecision(p) : fixe le nombre de chiffres affichés
setw(n) : fixe la largeur de l‟affichage
setbase(b) : fixe la base de numération
Les quatre manipulateurs ci-dessus, sauf setprecision(), n‘agissent que sur la prochaine
sortie. Pour les utiliser, inclure la librairie <iomanip.h>.
Exemple :
cout << setbase(16) << 256 << endl; // affiche 100 et passe à la ligne
cout << setprecision(5) << setfill(‟*‟) << setw(10) << 123.45678; // affiche ****123.46
4. Instructions
4.1.Instruction-expression
Forme :
<expression>;
Cette instruction n‘est utile que si l‘<expression> a un effet de bord.

Exemples :
i++;
5; // correct, mais sans intérêt !
; // instruction vide
i += j = 3; // ce genre d‟instruction est à éviter !
4.2.Instruction-bloc
Forme :
{
<déclarations et instructions>
}
Exemple :
{
int i = 3, j;
double x = 2.2, y = 3.3;
y = 0.5 * (x + y);
int k = 1 - (j = i);
}
4.3.Structures de contrôle
Ce sont des instructions qui permettent de contrôler le déroulement des opérations
effectuées par le programme : instructions if et switch (branchements conditionnels),
instructions while, do et for (boucles). Se reporter aux paragraphes suivants.
4.4.Visibilité d‘une variable
Le domaine de visibilité d‟une variable est limité au bloc où cette variable est
déclarée, et après sa déclaration.
On dit aussi que les variables déclarées dans un bloc sont locales à ce bloc.
Si une variable est locale à un bloc B, on ne peut y faire référence en dehors de ce bloc,
mais on peut l‘utiliser à l‘intérieur de B et dans tout bloc inclus lui-même dans B.
Dans un même bloc, il est interdit de déclarer deux variables avec le même nom. Mais
cela est possible dans deux blocs distincts, même si l‘un des blocs est inclus dans l‘autre.
Lorsque dans un fichier, une variable est déclarée en dehors de tout bloc (c‘est-à-dire au
niveau principal), on dit qu‘elle est globale ; elle est alors visible de tout le fichier, à partir de
l‘endroit où elle est déclarée. Cette règle de visibilité s‘appliquera également aux fonctions.
5. Fonctions
5.1.Terminologie
En C++, la partie exécutable d‟un programme (c‟est-à-dire celle qui comporte des
instructions) n‟est composée que de fonctions. Chacune de ces fonctions est destinée à effectuer
une tâche précise et renvoie généralement une valeur, résultat d‟un calcul.
Une fonction est caractérisée par :

 son nom,
 le type de valeur qu‟elle renvoie,
 l‟information qu‟elle reçoit pour faire son travail (paramètres),
 l‟instruction-bloc qui effectue le travail (corps de la fonction).
Les trois premiers éléments sont décrits dans la déclaration de la fonction. L‘élément n◦4
figure dans la définition de la fonction.
Toute fonction doit être définie avant d‟être utilisée.
Dans un fichier-source untel.cpp, il est possible d‘utiliser une fonction qui est définie
dans un autre fichier. Mais, pour que la compilation s‘effectue sans encombre, il faut en
principe que cette fonction soit déclarée dans untel.cpp (en usant au besoin de la directive
#include).
La définition d‘une fonction se fait toujours au niveau principal. On ne peut donc pas
imbriquer les fonctions les unes dans les autres, comme on le fait en Pascal.
5.2.Déclaration d‘une fonction
Elle se fait grâce à un prototype de la forme suivante :
<type> <nom>(<liste de paramètres formels>);
où <type> est le type du résultat, <nom> est le nom de la fonction et <liste de paramètres
formels> est composé de zéro, une ou plusieurs déclarations de variables, séparées par des
virgules.
Exemples :
double Moyenne(double x, double y);
char LireCaractere();
void AfficherValeurs(int nombre, double valeur);
Remarque : la dernière fonction n‘est pas destinée à renvoyer une valeur ; c‘est pourquoi le
type du résultat est void (une telle fonction est parfois appelée procédure).
5.3.Définition d‘une fonction
Elle est de la forme suivante :
<type> <nom>(<liste de paramètres formels>)
<instruction-bloc>
Donnons par exemple les définitions des trois fonctions déclarées ci-dessus :
double Moyenne(double x, double y){
return (x + y) / 2.0;
}
char LireCaractere(){
char c;
cin >> c;
return c;
}
void AfficherValeurs(int nombre, double valeur){
cout << ‟\t‟ << nombre << ‟\t‟ << valeur << ‟\n‟;
}
A retenir :
L‟instruction return <expression>; interrompt l‟exécution de la fonction.
La valeur de l‟<expression> est la valeur que renvoie la fonction.
5.4.Utilisation d‘une fonction
Elle se fait grâce à l‘appel de la fonction. Cet appel est une expression de la forme :
<nom_fonction>(<liste d‟expressions>) ;
Mécanisme de l‘appel :
 chaque expression de la <liste d‘expressions> est évaluée,

 les valeurs ainsi obtenues sont transmises dans l‘ordre aux paramètres formels,
 le corps de la fonction est ensuite exécuté,
 la valeur renvoyée par la fonction donne le résultat de l‘appel.
Si la fonction ne renvoie pas de valeur, le résultat de l‘appel est de type void.
Voici un bout de programme avec appel des trois fonctions précédentes :
double u, v;
cout << "\nEntrez les valeurs de u et v :";
cin >> u >> v;
double m = Moyenne(u, v);
cout << "\nVoulez-vous afficher la moyenne ? ";
char reponse = LireCaractere();
if (reponse == ‟o‟)
AfficherValeurs(2, m);
5.5.Arguments par défaut

On peut, lors de la déclaration d‘une fonction, choisir pour les paramètres des valeurs par
défaut (sous forme de déclarations-initialisations figurant à la fin de la liste des paramètres
formels).
Par exemple :
void AfficherValeurs(int nombre, double valeur = 0.0);
Les deux appels suivants sont alors corrects :
AfficherValeurs(n, x);
AfficherValeurs(n); // équivaut à : AfficherValeurs(n, 0.0);
5.6.Exemple de programme
Voici un petit programme complet écrit en C++ :
// ------------------- fichier gazole.cpp ---------------------
#include <iostream.h> // pour les entrées-sorties
const double prix_du_litre = 0.89; // déclaration du prix du litre de gazole (en
euros) comme constante (hum!)
int reserve = 10000; // déclaration de la réserve de la pompe, en litres
double prix(int nb) // définition d‟une fonction appelée "prix" :
// cette fonction renvoie le prix de nb litres de gazole
{
return nb * prix_ du_litre;
}
int delivre(int nb) // définition d‟une fonction appelée "delivre": cette fonction
renvoie 0
// si la réserve est insuffisante, 1 sinon et délivre alors nb litres
{
if (nb > reserve) // instruction if : voir la section suivante
return 0;
reserve -= nb;
return 1;
}
int main() // définition de la fonction principale
{
int possible;
do // instruction do : voir la section suivante
{
int quantite;
cout << "Bonjour. Combien voulez-vous de litres de gazole ? ";
cin >> quantite;
possible = delivre(quantite);
if (possible)
cout << "Cela fait " << prix(quantite) << " euros.\n";
}
while (possible);
cout << "Plus assez de carburant.\n";
return 0; // la fonction main renvoie traditionnellement un entier
}
Comme le montre le programme précédent, il est tout-à-fait possible de n‘écrire qu‘un
seul fichier-source .cpp contenant toutes les déclarations et instructions. Cependant, pour un
gros programme, il est recommandé d‘écrire plusieurs fichiers-source, chacun étant spécialisé
dans une catégorie d‘actions précise. Cette technique sera d‘ailleurs de rigueur quand nous
ferons de la programmation-objet.
A titre d‘exemple, voici le même programme, mais composé de trois fichiers-sources
distincts. On remarquera que le fichier d‘en-tête est inclus dans les deux autres fichiers (voir
la section suivante) :
// ------------------- fichier pompe.h ----------------------
const double prix du litre = 0.89; // déclaration du prix du litre de gazole (en euros)
double prix(int nb); // déclaration de la fonction prix
int delivre(int nb); // déclaration de la fonction delivre
// ------------------- fichier pompe.cpp --------------------
#include "pompe.h" // pour inclure les déclarations précédentes
int reserve = 10000; // déclaration de la réserve de la pompe, en litres
double prix(int nb) // définition de la fonction prix
{
....... // comme ci-dessus
}
int delivre(int nb) // définition de la fonction delivre
{
}
// ------------------- fichier clients.cpp ------------------
#include <iostream.h> // pour les entrées-sorties
#include "pompe.h" // pour les déclarations communes
int main() // définition de la fonction principale
{
}
5.7.Passage des paramètres dans une fonction

Supposons que nous voulions définir une fonction echange permettant d‘échanger les
valeurs de deux variables entières.
 Première version, naïve :
void echange(int a, int b) // version erronée
{
int aux; // variable auxiliaire servant pour l‟échange
aux = a; a = b; b = aux;
}
Ici l‘expression echange(x, y) (où x et y sont de type int) n‘a aucun effet sur x et y. En
effet, comme il a été dit dans la section précédente, lors de l‘appel de la fonction, les valeurs
de x et y sont recopiées dans les variables locales a et b (on parle de passage par valeur) et ce
sont les valeurs de ces variables a et b qui sont échangées.
 Deuxième version, avec des références :
void echange(int &a, int &b) // version correcte, style C++
{
int aux;
aux = a; a = b; b = aux;
}
Cette fois, l‘expression echange(x, y) réalise correctement l‘échange des valeurs de x et
y, car les variables a et b coïncident avec les variables x et y (on parle de passage par
référence).
 Troisième version moins pratique, avec des pointeurs :
void echange(int *a, int *b) // version correcte, style C
{
int aux;
aux = *a; *a = *b; *b = aux;
}
Pour échanger les valeurs de x et y, il faut alors écrire echange(&x, &y), c‘est-à-dire
passer à la fonction les adresses de x et y (on parle de passage par adresse).
6. Instructions conditionnelles
6.1.L‘instruction if
Forme :
if (<expression entière>)
<instruction1>
else
<instruction2>
Mécanisme : l‘<expression entière> est évaluée.

 si sa valeur est différente de 0, l‘<instruction1> est effectuée,
 si sa valeur est nulle, l‘<instruction2> est effectuée.
En C++, il n‘y a pas de type booléen (c‘est-à-dire logique). On retiendra que :
Toute expression entière différente de 0 (resp. égale à 0) est considérée
comme vraie (resp. fausse).
Remarque 1 : La partie else <instruction2> est facultative.

Remarque 2 : <instruction1> et <instruction2> sont en général des instructions-blocs
pour permettre d‘effectuer plusieurs actions.
6.1.1. Opérateurs booléens
Les opérateurs booléens sont entre autres :
! : non,
&& : et,
|| : ou.
L‘évaluation des expressions booléennes est une évaluation courte. Par exemple,
l‘expression u && v prend la valeur 0 dès que u est évalué à 0, sans que v ne soit évalué.
6.1.2. Opérateurs de comparaison
Les opérateurs de comparaison en C++ sont les suivants :
== : égal,
!= : différent,
< : strictement inférieur,
> : strictement supérieur,
<= : inférieur ou égal,
>= : supérieur ou égal.
Exemple :
On veut définir une fonction calculant le maximum de trois entiers.
Première solution :
int Max(int x, int y, int z) // calcule le maximum de trois entiers
{
if ((x <= z) && (y <= z))
return z;
if ((x <= y) && (z <= y))
return y;
return x;
}
Deuxième solution, avec une fonction auxiliaire calculant le maximum de deux entiers :
int Max(int x, int y) // calcule le maximum de deux entiers

{
if (x < y)
return y;
return x;
}
int Max(int x, int y, int z) // calcule le maximum de trois entiers
{
return Max(Max(x, y), z);
}
Comme on le voit sur cet exemple, deux fonctions peuvent avoir le même nom, dès lors
qu‘elles diffèrent par le nombre ou le type des paramètres.
6.2.L‘instruction switch
Cette instruction permet un branchement conditionnel multiple.
Forme :
switch (<expression>){
case <valeur1> :
<instructions>
case <valeur2> :
<instructions>
...
case <valeurn> :
<instructions>
default :
<instructions>
}
Mécanisme :
L‘<expression> est évaluée. S‘il y a un case avec une valeur égale à la valeur de
l‘<expression>, l‘exécution est transférée à la première instruction qui suit ce case ; si un tel
case n‘existe pas, l‘exécution est transférée à la première instruction qui suit default :.
Remarque 1 : La partie default : <instructions> est facultative.
Remarque 2 : L‘instruction switch est en général utilisée en conjonction avec l‘instruction
break; qui permet de sortir immédiatement du switch.
Exemple :
switch (note / 2) // on suppose note entier entre 0 et 20
{
case 10 :
case 9 :
case 8 :
mention = "TB";
break;
case 7 :
mention = "B";
break;
case 6 :
mention = "AB";
break;
case 5 :
mention = "P";
break;
default :
mention = "AJOURNE";
}
6.3.Les boucles
6.3.1. L’instruction while
Forme :
while (<expression entière>)
<instruction>
Mécanisme :
L‘<expression entière> est d‘abord évaluée. Tant qu‘elle est vraie (c‘est-à-dire différente
de 0), l‘<instruction> est effectuée.
Schématiquement :
On remarque que le test est effectué avant la boucle.

6.3.2. L’instruction do
Forme :
do
<instruction>
while (<expression entière>);
Mécanisme :
L‘<instruction> est effectuée, puis l‘<expression entière> est évaluée. Tant qu‘elle est
vraie (c‘est-à-dire différente de 0), l‘<instruction> est effectuée.
Schématiquement :
On remarque que le test est effectué après la boucle.

6.3.3. L’instruction for
Forme :
for (<expression1>; <expression2>; <expression3>)
<instruction>
Le mécanisme est équivalent à :

<expression1>; // initialisation de la boucle
while (<expression2>) // test de continuation de la boucle
{
<instruction>
<expression3>; // évaluée à la fin de chaque boucle
}
Remarque 1 : Une boucle infinie peut se programmer ainsi :

for (;;)
<instruction>
Remarque 2 : Dans une boucle, on peut utiliser les instructions :

break; pour abandonner immédiatement la boucle et passer à la suite,
continue; pour abandonner l‘itération en cours et passer à la suivante, mais l‘usage de ces
deux instructions se fait souvent au détriment de la clarté.
Exemple :
Ecrivons un bout de programme permettant d‘entrer au clavier dix nombres entiers et qui
affiche ensuite la moyenne arithmétique de ces dix nombres.
Code C++ avec while :
int n, somme = 0;
int i = 0;
cout << "Quand on le demande, tapez un entier suivi de <entrée>\n";
while (i < 10) // boucle version while
{
cout << "Entrée ? ";
cin >> n;
somme += n;
i++;
}
cout << "La moyenne est " << somme / 10.0;
Code C++ avec la boucle do …… while:

do // boucle version do
{
cin >> n;
somme += n;
i++;
}
while (i < 10);
Code C++ avec la boucle do …… while:

for (i = 0; i < 10; i++) // boucle version for
{
cin >> n;
somme += n;
}
6.3.4. Expression conditionnelle unaire ?
Forme :
<expression0> ? <expression1> : <expression2>
Fonctionnement :
<expression0> est d‘abord évaluée.
 si elle est non nulle, <expression1> est évaluée et donne sa valeur à l‘expression
conditionnelle,
 si elle est nulle, <expression2> est évaluée et donne sa valeur à l‘expression
conditionnelle.
Exemple :
int Pgcd(int a, int b) // calcule le pgcd de deux entiers positifs
// variante de (2.7.5) dans le style fonctionnel
{
if (a == b) return a;
return a > b ? Pgcd(a - b, b) : Pgcd(b - a, a);
}
6.4.Du bon choix d‘une boucle

Voici quelques principes qui pourront nous guider dans le choix d‘une boucle :
– Si l‘on sait combien de fois effectuer la boucle : utiliser for.
– Sinon, utiliser while ou do …. while :
 s‘il y a des cas où l‘on ne passe pas dans la boucle : utiliser while,
 sinon, utiliser do (ou do … while).

Exemple : nous voulons définir une fonction calculant le pgcd de deux entiers > 0 en
n‘effectuant que des soustractions.
Principe : soustraire le plus petit nombre du plus grand, et recommencer jusqu‘à ce que
les deux nombres soient égaux ; on obtient alors le pgcd. Par exemple, partant de 15 et 24, on
obtient :
(15, 24) → (15, 9) → (6, 9) → (6, 3) → (3, 3) et le pgcd est 3. Connaissant les nombres a
et b de départ, on ne peut pas savoir a priori combien d‘itérations seront nécessaires. De plus
si a = b, on a tout de suite le résultat, sans opération. Nous choisirons donc une boucle while,
d‘où :
int Pgcd(int a, int b) // calcule le pgcd de a et b entiers positifs
{
while (a != b)
if (a > b)
a -= b;
else
b -= a;
return a;
}
7. Compléments
Expression virgule
Forme :
<expression1> , <expression2>
Fonctionnement :
 <expression1> est évaluée, sa valeur est oubliée
 <expression2> est ensuite évaluée et donne sa valeur à l‘expression virgule.
Cette expression n‘est intéressante que si <expression1> a un effet de bord.
8. Fonctions utiles
Nous donnons dans cette section quelques fonctions de la bibliothèque standard.
Fonctions mathématiques : elles sont déclarées dans math.h. Il y a notamment les
fonctions suivantes, de paramètre double et de résultat double :
- floor (resp. ceil) : partie entière par défaut (resp. par excès),
- fabs : valeur absolue,
- sqrt : racine carrée,
- pow : puissance (pow(x,y) renvoie xy),
-exp, log, log10,
- sin, cos, tan, asin, acos, atan, sinh, cosh, tanh : fonctions trigonométriques.
Nombres aléatoires :
Il faut inclure stdlib.h et time.h. Alors :
 On initialise le générateur de nombres aléatoires (de préférence une seule fois) grâce à
l‘instruction srand((unsigned) time(NULL));
 Ensuite, chaque appel de la fonction rand() donne un entier aléatoire compris entre 0
et RAND MAX (constante définie dans stdlib.h).
Effacement de l’écran :
 Instruction system("cls"); (la fonction system() est déclarée dans stdlib.h).
Arrêt du programme :
 l‘instruction exit(1) provoque l‘arrêt immédiat du programme (la fonction exit() est
déclarée dans stdlib.h).
9. Eléments du langage
9.1.Enumérations
Les énumérations sont des listes de noms représentant les valeurs entières successives 0, 1, 2,
...
Une énumération se définit par un énoncé de la forme :
enum <nom> { <liste de noms> };
Exemples :
enum Jour {dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi};
enum Couleur {coeur, pique, carreau, trefle};
enum Vache {blanchette, noiraude, gertrude};
Le premier énoncé équivaut à la déclaration des constantes entières :
const int dimanche = 0;
const int lundi = 1;
const int mardi = 2;
etc . . .
et attribue à ces constantes un type appelé Jour.

On pourra utiliser les énumérations pour déclarer des variables, comme par exemple :
Jour fatal;
Couleur c;
Vache folle = gertrude;
9.2.Tableaux
Un tableau est une collection indicée de variables de même type.
Forme de la déclaration :
<type> <nom> [<taille>];
où :
<type> est le type des éléments du tableau,
<nom> est le nom du tableau,
<taille> est une constante entière égale au nombre d‘éléments du tableau.
Exemples :
int tab1[2]; // tableau de deux entiers
char mot[10], s[256]; // tableaux de respectivement 10 et 256 caractères
double tab2[3]; // tableau de trois nombres réels
Vache troupeau[1000]; // tableau de mille vaches
Note :
Si t est un tableau et i une expression entière, on note t[i] l‟élément d‟indice i du
tableau. Les éléments d‟un tableau sont indicés de 0 à taille − 1.
Par exemple, le tableau fraction déclaré ci-dessus représente deux variables entières qui
sont fraction[0] et fraction[1]. Ces variables se traitent comme des variables ordinaires ; on
peut par exemple écrire :
fraction[0] = 1;
fraction[1] = 2; etc.
Remarque : Les éléments d‘un tableau sont stockés en mémoire de façon contiguë, dans
l‘ordre des indices.
Il est possible de déclarer des tableaux à deux indices (ou plus). Par exemple, en écrivant :
int M[2][3];
On déclare un tableau d‘entiers M à deux indices, le premier indice variant entre 0 et 1, le

second entre 0 et 2. On peut voir M comme une matrice d‘entiers à 2 lignes et 3 colonnes. Les
éléments de M se notent M[i][j].
Comme pour les variables ordinaires, on peut faire des déclarations-initialisations de
tableaux. En voici trois exemples :
int T[3] = {5, 10, 15};
char voyelle[6] = {‟a‟, ‟e‟, ‟i‟, ‟o‟, ‟u‟, ‟y‟};
int M[2][3] = {{1, 2, 3}, {3, 4, 5}}; // ou : int M[2][3] = {1, 2, 3, 3, 4, 5};
9.2.1. Déclaration typedef

Elle permet d‘attribuer un nom à un type.
Forme générale :
typedef <déclaration>
où <déclaration> est identique à une déclaration de variable, dans laquelle le rôle du nom
de la variable est joué par le nom du type que l‘on veut définir.
C‘est très pratique pour nommer certains types de tableaux.
Exemples :
const int DIM = 3;
typedef float Vecteur[DIM]; // définit un type Vecteur (= tableau de trois réels)
typedef int Matrice[2][3]; // définit un type Matrice
typedef char Phrase[256]; // définit un type Phrase
Cela permet de déclarer ensuite, par exemple :
Vecteur U, V = {0.0, 0.0, 0.0}, W;

Matrice M;
Phrase s;
9.2.2. Utilisation des tableaux
On retiendra les trois règles suivantes :
Les tableaux peuvent être passés en paramètres dans les fonctions,
Les tableaux ne peuvent être renvoyés (avec return) comme résultats de fonctions,
L‟affectation entre tableaux est interdite.
Exemple 1: Instruction qui copie le vecteur U dans V :

for (int i = 0; i < DIM; i++)
V[i] = U[i];
Exemple 2 : Fonction qui affiche un vecteur :
void Affiche(Vecteur V) // affiche les composantes du vecteur V
{
for (int i = 0; i < DIM; i++)
cout << V[i] << " ";
}
Exemple 3 : Fonction renvoyant un vecteur nul :

Vecteur Zero(){
Vecteur Z;
for (int i = 0; i < DIM; i++) ILLEGAL !
Z[i] = 0.0;
return Z;
}
9.3.Chaînes de caractères
Note :
En C++, une chaîne de caractères n‟est rien d‟autre qu‟un tableau de caractères, avec
un caractère nul ‟\0‟ marquant la fin de la chaîne.
Exemples de déclarations :
char nom[20], prenom[20]; // 19 caractères utiles
char adresse[3][40]; // trois lignes de 39 caractères utiles
char turlu[10] = {‟t‟, ‟u‟, ‟t‟, ‟u‟, ‟\0‟}; // ou : char turlu[10] = "tutu";
Comme il a été dit plus haut, les valeurs explicites de type chaîne de caractères sont
écrites avec des guillemets. Par exemple :
prenom = "Antoine"; //illégal
strcpy(prenom, "Antoine"); // correct : voir ce qui suit
On peut représenter le tableau prenom par le schéma suivant :
Le nombre de caractères précédant ‘\0‘ s‘appelle la longueur de la chaîne.

Les chaînes de caractère peuvent être saisies au clavier et affichées à l‘écran grâce aux
objets habituels cin et cout.
Dans la bibliothèque standard du C++, il y a de nombreuses fonctions utilitaires sur les
chaînes de caractères. Parmi elles :
strlen(s) (dans string.h) : donne la longueur de la chaîne s
strcpy(dest, source) (dans string.h) : recopie la chaîne source dans dest
strcmp(s1,s2) (dans string.h) : compare les chaines s1 et s2 :renvoie une valeur < 0, nulle
ou > 0 selon que s1 est inférieure, égale ou supérieure à s2 pour l‟ordre alphabétique.
gets(s) (dans stdio.h) :lit une chaîne de caractères tapée au clavier, jusqu‟au premier
retour à la ligne (inclus) ; les caractères lus sont rangés dans la chaîne s, sauf le retour à la
ligne qui y est remplacé par ‟\0‟.
9.3.1. Utilisation des chaînes de caractères
Nous en donnerons deux exemples.
Exemple 1 : Fonction qui indique si une phrase est un palindrome (c‘est-à-dire qu‘on peut la
lire aussi bien à l‘endroit qu‘à l‘envers) :
int Palindrome(Phrase s) // teste si s est un palindrome
{
int i = 0, j = strlen(s) - 1;
while (s[i] == s[j] && i < j)
i++, j--;
return i >= j;
}
Exemple 2 : Instructions qui, à partir d‘une chaîne s, fabrique la chaîne t obtenue en

renversant s :
for (int i = 0, j = strlen(s) - 1; i < strlen(s); i++, j--)
t[i] = s[j];
t[strlen(s)] = ‟\0‟;
9.3.2. Quelques fonctions des caractères

On retrouve dans la bibliothèque ctype.h quelques fonctions utiles concernant les
caractères comme:
tolower() convertit une lettre majuscule en minuscule
toupper() convertit une lettre minuscule en majuscule
9.4.Pointeurs, références
9.4.1. Adresses
La mémoire d‘un ordinateur peut être considérée comme un empilement de cases-
mémoire. Chaque case-mémoire est repérée par un numéro qu‘on appelle son adresse (en
général un entier long). Si ma_var est une variable d‘un type quelconque, l‘adresse où est
stockée la valeur de ma_var s‘obtient grâce à l‘opérateur d‘adresse & : cette adresse se note
&ma_var :
9.4.2. Pointeurs
Un pointeur est une variable qui contient l‘adresse d‘une autre variable.
La déclaration d‘un pointeur est de la forme suivante :
<type> *<nom>;
Exemple :
int *p;
La variable p est alors un pointeur sur un int ; la variable entière dont p contient l‘adresse
est dite pointée par p et se note *p.
Schématiquement :
Une variable pointée s‘utilise comme une variable ordinaire.

Exemple :
int *p, *q, n;
n = -16;
*p = 101;
*q = n + *p; // donne à *q la valeur 85
Un pointeur est toujours lié à un type (sur lequel il pointe).
Exemple :
int *ip;
double *dp;
dp = ip; // illégal car ip et dp ne sont pas de même type
*dp = *ip; // correct (conversion implicite de type)
Remarque : Il y a dans stdlib.h la valeur pointeur NULL (égale à 0) qui est compatible avec
tout type de pointeur. Ainsi :
dp = NULL; // légal
ip = NULL; // légal
9.4.3. Références
Une référence est une variable qui coïncide avec une autre variable.
La déclaration d‘une référence est de la forme suivante :
<type> &<nom> = <nom var>;
Exemple :
int n = 10;
int &r = n; // r est une référence sur n
Cela signifie que r et n représentent la même variable (en particulier, elles ont la même
adresse). Si on écrit par la suite : r = 20, n prend également la valeur 20.
Attention :
double somme, moyenne;
double &total = somme; // correct : total est une référence sur somme
double &valeur; // illégal : pas de variable à laquelle se référer
double &total = moyenne; // illégal : on ne peut redéfinir une référence
9.5.Pointeurs et tableaux
Considérons la déclaration suivante :
int T[5]; // T est un tableau de 5 entiers
T est en réalité un pointeur constant sur un int et contient l‘adresse du premier élément du
tableau. Donc T et &T[0] sont synonymes. On a le droit d‘écrire par exemple :
int *p = T;
p[2]; // = T[2]
A noter :
int U[5];
U = T; // illégal : U ne peut être modifié (pointeur constant)
Comme conséquence de la section ‗Pointeur et tableaux‘, on voit que, comme paramètres

de fonctions, les tableaux passent par adresse. Donc :
 il n‘y a pas de recopie du contenu du tableau (d‘où gain de temps),
 la fonction peut modifier le contenu du tableau.
Par exemple, en définissant :
void annule(int V[]) // pour un paramètre tableau : inutile d‟indiquer la taille
{
for (int i = 0; i < 5; i++)
V[i] = 0;
}
On peut alors mettre à zéro un tableau de cinq entiers T en écrivant annule(T).

9.6.Cas des chaînes de caractères
Une chaîne de caractères est habituellement déclarée :
 soit comme tableau de caractères; exemple : char nom[10];
 soit comme pointeur sur un caractère ; exemple : char *nom;
Avec la première déclaration, l‘espace-mémoire est automatiquement réservé pour
recevoir 10 caractères.
Avec la deuxième, aucun espace n‘est a priori réservé : il faudra faire cette réservation
nous-même (voir paragraphe suivant).
D‘autre part, avec la deuxième déclaration, le pointeur nom peut être modifié. Avec la
première, il ne le peut pas.
A titre d‘exemple, voici deux définitions équivalentes de la fonction strcpy mentionnée
dans la section ‗chaîne de caractères‘. Cette fonction recopie une chaîne de caractères source
dans une chaîne dest (attention : l‘expression dest = source recopierait le pointeur mais pas la
chaîne !) :
Exemple de code :
char *strcpy(char *dest, char *source) // copie source dans dest
{
for (int i = 0; source[i] != ‟\0‟; i++)
dest[i] = source[i];
dest[i] = source[i]; // copie le terminateur ‟\0‟
return dest;
}
char *strcpy(char *dest, char *source) // copie source dans dest
{
char *temp = dest;
while (*source)
*dest++ = *source++;
*dest = *source; // copie le terminateur ‟\0‟
return temp;
}
9.7.Gestion de la mémoire — variables dynamiques
Supposons déclaré :
int *p; // p : pointeur sur int
Pour l‘instant, p ne pointe sur rien. Il faut réserver l‘espace-mémoire nécessaire à un int
par l‘instruction :
p = new int; // new : opérateur d‟allocation mémoire
Cette fois, p contient une véritable adresse (ou NULL s‘il n‘y a plus assez de mémoire).
On peut alors utiliser la variable pointée par p (qu‘on nomme variable dynamique par
opposition aux variables ordinaires qualifiées de statiques). Par exemple :
*p = 12; // ou tout autre traitement...
Lorsqu‘on n‘a plus besoin de la variable *p, il faut libérer l‘espace-mémoire qu‘elle
occupe par l‘instruction:
delete p; // delete : opérateur de désallocation mémoire
L‘expression *p est dès lors illégale, jusqu‘à une prochaine allocation par : p = new int;
Cas d‘un tableau dynamique, supposons la déclaration suivante :
int *T;
L‘allocation-mémoire nécessaire pour recevoir n entiers s‘écrira :

T = new int [n]; // T est maintenant un tableau de n entiers
Ici, l‘intérêt est que n peut être n‘importe quelle expression entière, et pas seulement une
constante comme dans la déclaration d‘un tableau statique. La taille du tableau peut donc être
décidée au moment de l‘exécution, en fonction des besoins.
En fin de traitement, la libération de l‘espace-mémoire occupé par T s‘écrit :
delete [] T; // désallocation mémoire d‟un tableau dynamique
A retenir :
Grâce aux pointeurs, on peut manipuler des structures de données dynamiques dont la
taille n‟est déterminée qu‟au moment de l‟exécution.
b. L‘espace-mémoire (nombre d‘octets) occupé par une valeur de type un type est
donné par l‘opérateur sizeof : on écrira sizeof un type ou encore sizeof une expression, où
une expression est une expression de type un type.
NB : Il est très important de très bien connaître le fonctionnement des pointeurs et des
références car l‘intérêt de la programmation objet en C++ repose sur leur utilisation intensive.
Il faut noter que les opérateurs & et * sont inverses l‘un de l‘autre. On a toujours :
*(&x) = x et &(*p) = p
Attention, on ne peut pas déréférencer un pointeur qui ne contient pas une adresse valide.
int * q ;
*q = 7 ; // plantage
Il faut initialiser le pointeur avant :

int * q = &x;
*q = 7 ; // ok
10. Spécificités de C++ surlangage de C

C++ dispose d‘un certain nombre de spécificités par rapport à C qui ne sont pas axées sur
l‘orienté objet. Ces spécificités sont entre autre autres :
 le commentaire,
 l‘emplacement libre des déclarations,
 les arguments par défaut,
 la surdéfinition de fonction,
 les opérateurs new et delete,
 les fonctions en ligne.
10.1. Le commentaire
Pour écrire des commentaires dans un programme, le programmeur dispose toujours des
commentaires C avec /* et */ et aussi de commentaires en fin de ligne avec //
cout << « bonjour » ; // ceci est une formule de politesse
On peut utiliser les deux techniques comme suit.

/* ceci est un commentaire en C // donc ce double slash ne sert à rien */
Ou encore :
// ceci est un commentaire en C++ /* donc ce slash etoile ne sert à rien */
Mais pas :
// ceci est un commentaire en C++ /* donc ce slash étoile ne sert à rien
et cela donne une erreur de compilation si le étoile slash n‟est pas sur la
même ligne */
10.2. Emplacement des déclarations de variables

L‘emplacement des déclarations est libre en C++ ; le programmeur n‘est pas obligé de les
mettre au début d‘une fonction. Par contre, on ne peut utiliser la variable déclarée que dans les
instructions du bloc où est effectuée la déclaration et postérieures à la déclaration. L‘avantage
de cette spécificité du C++ est de pouvoir déclarer une variable juste au moment où l‘on en a
besoin et cela clarifie le programme. Mais cet avantage est bien maigre.
Exemple :
void f() {
...
i = 4 ; // incorrect
...
int i ; // i est déclaré ici
...
i = 4 ; // correct
...
{
...
float f ; // f est declare ici
...
f = 4.0 ; // correct
...
} // fin de la portee de f
...
f = 4.0 ; // incorrect
...
i = 5 ; // correct
...
} // fin de la portee de i
10.3. Passage de paramètres par référence
En C, les arguments sont passés par valeur. Ce qui signifie que les paramètres d‘une
fonction C sont toujours en entrée de la fonction et pas en sortie de la fonction; autrement dit
les paramètres d‘une fonction ne peuvent pas être modifiés par la fonction.
Ci-dessous la fonction echange est censée échanger les valeurs des deux paramètres n et
p. Faisons une étude pratique de cette fonction. Il faut noter que la même fonction a été déjà
présentée dans la section précédente pour illustrer le même concept.
void echange(int a, int b) {
int c = a ;
a=b;
b=c;
}
main() {
int n = 10 ; int p = 20 ;
cout << « avant appel : « << n << « « << p << endl ;
echange(n, p) ;
cout << « après appel : « << n << « « << p << endl ;
}
Malheureusement, pour la raison invoquée plus haut, la sortie de ce programme est :

avant appel : 10 20
apres appel : 10 20
Les programmeurs C ont l‘habitude de palier à cet inconvénient du C en passant
l’adresse des paramètres en sortie d‘une fonction au lieu de passer la valeur. Ainsi, notre
exemple sera écrit :
void echange(int * a, int * b) {
int c = *a ;
*a = *b ;
*b = c ;
}
main() {
int n = 10 ; int p = 20 ;
cout << « avant appel : « << n << « « << p << endl ;
echange(&n, &p) ;
cout << « apres appel : « << n << « « << p << endl ;

}
La sortie de ce programme correspond à ce que notre intuition attend :
avant appel : 10 20
après appel : 20 10
Cette manipulation de pointeurs est lourde à gérer pour le programmeur. C++ palie à cet
inconvénient en permettant le passage de paramètres par référence ; la programmation
devient plus légère et le résultat correct. Il suffit de changer la déclaration de la fonction
echange :
void echange(int & a, int & b) { ... }
L‘appel de la fonction est le même que pour le passage par valeur :

echange(n, p) ;
On notera qu‘il n‘y a rien d‘extraordinaire. Pascal possède cette propriété de passage de
paramètres par référence et C++ ne fait que combler un manque important du C.
10.4. Arguments par défaut
En C, il est indispensable que l‘appel de la fonction contienne exactement le même
nombre et type d‘arguments que dans la déclaration de la fonction. C++ permet de
s‘affranchir de cette contrainte en permettant l‘usage d‘arguments par défaut.
void f(int, int = 12) ;
main () {
int n = 10 ; int p = 20 ;
f(n, p) ;
f(n) ;
}
void f(int a, int b) {
cout << « premier argument : « << a ;
cout << « second argument : « << b << endl ;
}
La sortie de ce programme est :

premier argument : 10 second argument : 20
premier argument : 10 second argument : 12
Lors d‘une déclaration avec des arguments par défaut, ceux-ci doivent être les derniers de
la liste des arguments.
Le programmeur doit fixer les valeurs par défaut dans la déclaration de la fonction ou
dans la définition.
10.5. Surdéfinition de fonction
On parle de surdéfinition lorsqu‘un symbole prend plusieurs significations différentes.
Ci-dessous le symbole sosie possède deux significations.
void sosie(int) ;
void sosie(float) ;
main () {
int n = 10 ; float x = 4.0 ;
sosie(n) ;
sosie(x) ;
}
void sosie(int a) {
cout << « sosie avec INT : « << a << endl ;
}
void sosie(float b) {
cout << « sosie avec FLOAT : « << b << endl ;
}
La sortie de ce programme est :
sosie avec INT : 10
sosie avec FLOAT : 4.0
10.6. Opérateurs new et delete
En C, la gestion dynamique de la mémoire fait appel aux fonctions malloc et free. En
C++, on utilise les fonctions new et delete.
Avec la déclaration :
int * ad ;
En C++ on alloue dynamiquement comme cela :
ad = new int ;
Alors qu‘en C il fallait faire comme ceci :
ad = (int *) malloc (sizeof(int)) ;
Plus généralement, si on a un type donné type, on alloue une variable avec :
new type ;
Ou un tableau de n variables avec :
new type [n] ;
On désalloue dynamiquement de la mémoire (allouée avec new) comme cela :
delete ad;
Plus généralement, on désalloue une variable x (allouée avec new) avec :
delete x;
Ou un tableau de variables (allouée avec new []) avec :

delete [] x ;
En C++, bien que l‘utilisation de malloc et free soit toujours permise, il est très conseillé
de n‘utiliser que new et delete.
10.7. Spécification « inline »

9.7.1. Rappel sur les macros en C
En C, on peut définir une macro avec le mot-clé define :
#define carre(A) A*A
Cela permet à priori d‘utiliser carre comme une fonction normale :

int a = 2 ;
int b = carre(a) ;
cout << « a = « << a << « b = « << b << endl ;
Le résultat sera correct dans ce cas simple :
a=2b=4
Quand il voit une macro, le C remplace partout dans le code les expressions carre(x) par
x*x.
L‘avantage d‘une macro par rapport à une fonction est la rapidité d‘exécution. En effet, le
temps à recopier les valeurs des paramètres disparaît. La contrepartie est un espace mémoire
du programme plus grand.
Plus embêtant sont les effets de bord des macros. Si l‘on programme :
b = carre(a++) ;
On attendrait le résultat suivant :
a=3b=4
En réalité, ce n‘est pas le cas car, à la compilation, le C remplace malheureusement

carre(a++) par a++*a++. Et à l‘exécution, le programme donne le résultat suivant :
a=4b=6
9.7.2. Les fonctions inline

Le C++ palie à cet inconvénient en permettant de définir des fonctions, dites en ligne,
avec le mot clé ‗inline’.
Exemple :
inline int carre(int x) { return x*x ; }
Une fonction définie avec le mot-clé inline aura le même avantage qu‘une macro en C, à
savoir un gain de temps d‘exécution et le même inconvénient, à savoir une plus grande place
mémoire occupée par le programme.
Note : L‘avantage des fonctions en ligne est la disparition des effets de bord.
II. PROGRAMMATION ORIENTEE OBJET
1. Classes et objets
Cette deuxième section du deuxième chapitre aborde les caractéristiques de C++ vis-à-vis
de la programmation orientée objet.
Il rappelle d‘abord le vocabulaire objet, notamment ce que signifie encapsulation, puis il

montre comment déclarer une classe C++, comment définir le corps des fonctions membres,
la distinction entre membres privés et publiques, l‘affectation d‘objets, les constructeurs et les
destructeurs, l‘exploitation d‘une classe avec des fichiers .h et .cpp et enfin les membres
statiques d‘une classe.
Vocabulaire objet
Nous rappelons dans cette section le vocabulaire employé en orienté objet. Et il donne la
correspondance entre le vocabulaire objet et le vocabulaire spécifique de C++.
1.1.Objet
Un objet est une entité, qui possède un état et un comportement. Pour définir ce qu‘est un
objet, les livres donnent souvent une équation du style de :
objet = état + comportement
1.2.Classe
Vue de la programmation objet, une classe est un type structuré de données. Nous
verrons qu‘une classe C++ est le prolongement des structures C (mot-clé struct).
Vue de la modélisation objet, une classe correspond à un concept du domaine modélisé.
Une classe regroupe des objets qui ont des propriétés et des comportements communs. En
C++, pour une classe, on dit aussi une classe.
Exemple de squelette d’une classe en C++ :
class Nom_class {
private:
// Déclaration des attributs et méthodes privés
protected:
// Déclaration des attributs et méthodes protégés
public:
// Déclaration des attributs et méthodes publics
};
1.3.Instance
Pour désigner un objet de la classe, on dit aussi une instance. « instance » est un
anglicisme qui possède une signification proche de celle de « exemple » en français. On dit
souvent qu‘une instance « instancie » une classe. Cela signifie que l‘instance est un exemple
de la classe. En C++, pour désigner une instance on dit plutôt un objet.
1.4.Attribut ou membre
L‘état d‘un objet est l ‗ensemble des valeurs de ses attributs. Un attribut est une propriété
de l‘objet. En C++, on dit membre.
1.5.Méthode ou fonction membre

Vue de la modélisation objet, une méthode est une opération que l‘on peut effectuer sur
un objet. Vue de la programmation objet, une méthode est une fonction qui s‘applique sur une
instance de la classe. En C++, on dit fonction membre.
1.6.Message
A l‘origine de la programmation orientée objet, un objectif était d‘avoir des
comportements d‘objets concurrents. On voulait qu‘ils « communiquent » en « envoyant »
et « recevant » des « messages ». Actuellement, tous les langages objet implémentent les
objets de manière fonctionnelle. C‘est-à-dire qu‘au lieu « d‘envoyer un message à un objet »,
on appelle une méthode, c‘est-à-dire que l‘on appelle une fonction qui manipule des données.
Donc, il faut être conscient de la correspondance suivante :
envoyer un message à un objet = appeler une méthode associée à l‟objet
recevoir un message = entrer dans le corps de la méthode appelée
2. Encapsulation des données

En POO pure, on suit le principe d‟encapsulation :
Tout attribut d‘une classe est caché dans l‘implémentation de la classe et il est accédé par
une méthode de lecture et une méthode d‘écriture située dans l‘interface de la classe.
Pour répondre à ce principe, C++ prévoit les mot-clés ‗private’ et ‗public’ pour dire si
un attribut est visible d‘un programme utilisateur de la classe. En ce sens, il permet de ne pas
encapsuler tous les attributs d‘une classe et permet de ne pas suivre le principe
d‘encapsulation à la lettre. Nous pensons que c‘est une bonne chose car de nombreuses
applications ne nécessitent pas d‘encapsuler toutes les données, d‘autres oui. D‘autres
langages objet, au contraire de C++, obligent le programmeur à suivre ce principe (Smalltalk
par exemple).
3. Déclaration et utilisation de classe
3.1.Déclaration de classe
Pour déclarer une classe HitFormatec en C++, on utilise le mot-clé ‗class‘ :
class HitFormatec { ...} ;
Le mot-clé class de C++ est une extension du mot-clé ‗struct’ de C et il suit une syntaxe
proche.
Exemple :
class Point {
int x ; // un membre
int y ; // un autre membre
public :
void initialise(int, int) ; // une fonction membre
void deplace(int, int); // encore une fonction membre
void affiche() ; // encore une fonction membre
};
x et y sont des membres de la classe Point.
Initialise, deplace et affiche sont des fonctions membres de la classe Point.
Noter que cet exemple suit le principe d‘encapsulation car, par défaut, les premiers
membres de la classe sont privés (x et y). Les fonctions membres dont la déclaration est
postérieure au mot clé public sont publiques.
3.2.Définition des fonctions membres de la classe
La déclaration d‘une classe doit être suivie de la définition de ses fonctions membres.
Chaque définition d‘une fonction membre suit la syntaxe de la définition d‘une fonction C
avec un nom préfixé par le nom de la classe et quatre points ‗::‘.
Le symbole „::‟ s „appelle l‟opérateur de résolution de portée.
Ci-dessous figure un exemple de définition des fonctions membres de la classe Point.

void Point::initialise(int a, int b) {
x = a;
y = b;
}
void Point::deplace(int dx, int dy) {
x += dx;
y += dy;
}
void Point::affiche() {
cout << « x = « << x << endl;
cout << « y = « << y << endl;
}
Noter que les membres (x et y) sont visibles des fonctions membres de la classe Point. Ils
sont utilisés simplement avec leur nom de variable déclaré dans la classe.
3.3.Utilisation de la classe
Voici un exemple d‘utilisation de la classe Point par un programme :
main() {
Point a, b ;
a.initialise(5, 2) ;
a.affiche() ;
a.deplace(8, 4) ;
a.affiche() ;
b.initialise(-1, 1) ;
b.affiche() ;
}
Pour appeler la fonction membre initialise sur l‘objet a, noter qu‘il faut écrire le nom de
l‘objet (a), un point (.) et le nom de la fonction membre (initialise).
3.4.Membres privés ou publiques

Pour l‘exemple précédent, une instruction du style de a.x = 3 ; dans le main() serait
rejetée à la compilation car x est un membre privé de la classe Point.
Note : Si x était un membre publique de la classe Point on pourrait le faire. Il faut noter que la
syntaxe est la même que pour les fonctions membres : on écrit le nom de l‘objet (x), un point
(.) et le nom du membre (x).
La déclaration d‘une classe est toujours du type :
class Toto {
... // des membres privés
public :
... // des membres publics
private :
... // encore des membres privés
public :
... // encore des membres publics
... // etc.
};
On peut mettre un mot-clé public ou private pour chaque membre si on le souhaite.
Si on omet le mot-clé public dans une classe, aucun de ses membres n‘est accessible de
l‘extérieur de la classe...
3.5.Affectation d‘objets
On peut affecter un objet dans un autre :
a=b;
Dans ce cas, les membres de b sont recopiés dans ceux de a.

3.6.Constructeur et destructeur d'objets
3.6.1. Le constructeur d’objets
En fait, une caractéristique de la POO est de maîtriser la création d‘objet, leur
initialisation et leur destruction. C++ répond à ce besoin avec la notion de constructeur
d‘objet pour la création et l‘initialisation et avec la notion de destructeur.
Un constructeur d‘objet est une fonction membre particulière d‘une classe qui est appelée
lors de la création d‘un objet, quel qu‘il soit. Son but est :
 d‟allouer un emplacement mémoire pour l‟objet,
 d‟initialiser les membres de l‟objet avec de bonnes valeurs de départ et
 de retourner l‟adresse de l‟emplacement mémoire choisi.
Dans notre exemple, le constructeur fait l‘équivalent de la fonction initialise et fait
l‘allocation de l‘emplacement mémoire.
3.6.2. Le destructeur d’objet
Le destructeur d‘objets a pour fonction de :
 remette l‟objet dans un état terminal et
 libérer l‟emplacement mémoire associé à l‟objet.

En fait, notre exemple précédent était approximatif et en bon C++, il faut écrire :
class Point {
...
public :
Point(int, int) ; // le constructeur de la classe
~Point() ; // le destructeur de la classe
...
};
Point : : Point(int a, int b) {
x=a;
y=b;
}
Point : : ~Point() {} // le destructeur ne sert pas dans cet exemple
main() {
Point a(5, 2) ;
...
Point b(-1, 1) ;
...
}
A partir du moment où un constructeur existe, il n‘est pas possible de créer un objet sans
fournir les arguments requis par le constructeur.
Note : Un destructeur ne possède jamais d‘argument.
L‘exemple suivant permet de comprendre les moments où sont appelés les constructeurs
et destructeurs d‘objets.
class Test {
int num ;
Test(int) ;
~Test() ;
};
Test : :Test(int n) {
num = n ;
cout << «++ « << num << endl ;
}
Test : :~Test() {
cout << «--« << num << endl ;
}
void fct(int p) {
Test x(2*p) ;
}
main() {
Test a(1) ;
fct(1) ;
fct(2) ;
}
La sortie du programme est :

++ 1
++ 2
-- 2
++ 4
-- 4
-- 1
Remarque : a est détruit à la sortie du programme main et les objets x sont détruits à la sortie
de fct.
4. Régles d'utilisation des fichiers .cpp et .h
Pour pouvoir effectivement réutiliser les classes programmées et les compiler
séparément, il est indispensable de les exploiter proprement et les ranger dans des fichiers qui
portent des noms corrects.
La déclaration d‟une classe Classe doit être mise dans un fichier classe.h
La définition d‟une classe Classe doit être mise dans un fichier classe.cpp
Si l‘on fait une analogie avec la programmation modulaire, (rappel 1 module = 1 interface
visible + 1 corps caché), on peut dire que :
Le fichier .cpp est le corps de la classe.
Le fichier .h est l‟interface de la classe.
Pour l‘instant, retenir qu‘un fichier classe.h possède la structure suivante :
#ifndef CLASSE_H
#define CLASSE_H
#include ... // includes de classes éventuelles
...
class Classe {
...
};
#endif
Et qu‘un fichier classe.cpp possède la structure suivante :
// fichier classe.cpp
#include « classe.h » // include de sa propre classe
#include ... // autres includes optionnels
...
Classe : :Classe(...) { // definition du constructeur
...
}
Classe : :~Classe() { // définition du destructeur
...
}.
.. // autres définitions de fonctions membres
Ces structures de fichiers sont correctes mais incomplètes. Elles seront affinées dans les
sections suivantes.
Elles permettent la réutilisation et la compilation séparée.
Note 1 : #ifndef, #define et #endif dans le .h servent de garde-fou pour que le fichier ne soit
effectivement inclus qu‘une seule fois lors d‘une compilation.
Note 2 : Il faut inclure obligatoirement le classe.h dans le fichier classe.cpp ; les autres sont
optionnels.
5. Membres statiques
Avec le qualificatif ‗static’ avant un membre d‘une classe, on peut spécifier qu‘un
membre est commun à tous les objets de la classe.
En modélisation objet, cela correspond aux attributs « de classe ». Un membre sans le
mot-clé static correspond à un attribut « d’instance ».
Class Exemple {
static int a ;
float b ;
public :
Exemple(float) ;
...
};
...
Exemple : :a = 0 ;// définition d‟un membre statique nécessaire
...
Exemple e(1), f(2) ;
...
Dans la classe Exemple, a est un membre statique, b un membre non statique.
Un membre statique doit être défini dans le .cpp tout comme une fonction membre sinon
une erreur sera produite à l‘édition de liens. La définition du membre statique permet son
initialisation. Ici a = 0 ;
e et f sont des objets avec e.b = 1 et f.b = 2
e et f ont le membre a en commun e.a = f.a = 0.
6. Propriétés des fonctions membres

De manière générale, toutes les améliorations concernant les fonctions restent valables
aussi les fonctions membres :
 surdéfinition de fonctions membres,
 arguments par défaut,
 objets transmis en argument d'une fonction membre, par valeur, adresse ou référence.
Nous ne les rappellerons pas dans cette section. Pour les apprendre il suffit d‘aller dans la
section « déclaration et utilisation des fonctions » et les différents modes de passage de
paramètres.
La suite de section comprend essentiellement les améliorations propres aux fonctions
membres à savoir:
 fonctions membres en ligne,
 fonctions membres statiques,
 appel des fonctions membres.
6.1.Fonctions membres en ligne
On peut mettre une fonction membre en ligne mais la syntaxe est différente de celle des
fonctions standards.
Au lieu de mettre le mot-clef ― inline‖ devant la définition de la fonction, on écrit le
corps de la fonction au même endroit que sa déclaration dans la classe.
Ci-dessous la fonction membre deplace de la classe Point est normale :
class Point { …
void deplace(int, int);
};
void Point::deplace(int dx, int dy) { x += dx; y += dy; };
Ci-dessous elle est inline bien que le mot-clef ne soit pas présent.
class Point { …
void deplace(int dx, int dy) { x += dx; y += dy; };
};
6.2.Fonctions membres statiques

L‘orienté objet définit deux types de méthodes dans une classe : les méthodes associées à
une instance de la classe (les méthodes dites ― d’instance ‖) et les méthodes non associables à
une instance de la classe mais associées à la classe toute entière (les méthodes dites ― de
classe ‖).
Le C++ permet ce genre de distinction avec le mot-clef ―static‖.
Une fonction membre statique C++ correspond à une méthode de classe dans le
vocabulaire objet. Une fonction membre non statique C++ correspond à une méthode
d‘instance dans le vocabulaire objet.
Ci-dessous, la fonction membre affiche_tout de la classe Point est statique et la fonction
membre affiche est normale.
class Point { …
void affiche();
static void affiche_tout();
};
Autoréférence: le mot-clé this

Quand le programme est dans une fonction membre d‘instance, le programmeur peut
manipuler l‘adresse de l‘instance courante avec le mot-clef ‗this’. En effet, this désigne
l‘adresse de l‘instance courante.
class Point { …
void affiche() { cout << “ mon adresse est ” << this << endl; }
};
this est utile, par exemple, dans un constructeur (ou un destructeur) pour stocker l‘adresse
de l‘objet construit (ou effacer l‘adresse de l‘objet détruit) d‘un tableau ou liste d‘instances ou
d‘un attribut d‘un autre objet.
this est un paramètre implicite des fonctions membres d'instance. Il faut savoir que le
préprocesseur d‘un compilateur C++ transforme toutes les fonctions membres d‘instance C++
par des fonctions C dont le premier paramètre est l‘adresse de l‘instance.
this n'a évidemment pas de sens dans une fonction membre de classe.
6.3.Appel des fonctions membres
L‘appel d‘une fonction membre peut se faire de plusieurs manières selon que la fonction
est une fonction membre d‘instance ou bien de classe.
Les règles sont les suivantes.
Pour une fonction membre de classe

Dans ce cas, le critère important est le lieu de l‘appel:
 Appel dans la classe ou dans une classe descendante :
Une fonction membre statique s‘appelle avec son nom au sens strict (cas A) de l‘exemple ci-
dessous.
 Appel hors de la classe et de ses descendantes:
Une fonction membre statique s‘appelle avec son nom préfixé du nom de la classe et de ::
(cas B).
Pour une fonction membre d’instance
Dans ce cas, le critère important est l‘instance sur laquelle on appelle la fonction:
 Avec l‘instance courante
Une fonction membre d‘instance s‘appelle avec son nom au sens strict (cas C) [ou bien,
mais c‘est redondant, préfixé de this-> (cas D)].
 Avec une autre instance que l‘instance courante
Une fonction membre d‘instance s‘appelle avec son nom au sens strict préfixé du nom de
l‘instance et d‘un point (.) (cas E) ou bien avec son nom au sens strict préfixé du nom d‘un
pointeur sur l‘instance considérée et d‘une flèche (->) (cas F).
Exemple :
class Truc { …
void a();
void b();
static void c();
static void d();
};
void Truc::a() {
d(); // cas A
b(); // cas C
this->b(); // cas D
Truc t ; t.b(); // cas E
Truc * pt = &t ; pt ->b(); // cas F
}
void Truc::b() {…}
void Truc::c() {
d(); // cas A
}
void Truc::d() {…}
main() {
Truc::d(); // cas B
}
Bien sûr, on peut être redondant :

void Truc::a() {
Truc::d(); // cas A
Truc::b(); // cas C
Truc t ; t.Truc::b(); // cas E
Truc * pt = &t ; pt ->Truc::b(); // cas F
}
Le C++ acceptera et cela marchera mais il vaut mieux éviter.

7. Construction, destruction et initialisation d‘objets
Ce paragraphe montre les différents comportements des objets C++ lors de leur durée de
vie. Il précise les qualificatifs des objets suivant leur type de déclaration, comment ils sont
initialisés et surtout le cas du constructeur par recopie.
7.1.Les différents qualificatifs des objets suivant leur type de déclaration
7.1.1. Les objets automatiques
Les objets automatiques sont les objets déclarés dans une fonction ou dans un bloc.
void f() {
Formatec t ; // t est construit ici
…{
Hit b ; // b est construit ici
…
} // b est détruit ici
}
t et b sont des objets automatiques. t est visible dans la fonction f et b est dans le bloc. A
la sortie de la fonction t est détruit. A la sortie du bloc, b est détruit.
7.1.2. Les objets statiques
Un objet statique est un objet déclaré avec le mot-clé static dans une déclaration de classe
ou dans une fonction ou bien à l‘extérieur de toute fonction. Un objet statique est créé avant le
début de l‘exécution du programme et il est détruit à la sortie du programme.
Exemple :
static Point a(1, 7);
7.1.3. Les objets dynamiques

Ce sont eux qui font tout l‘intérêt de la programmation orienté objet. Un objet dynamique
est un objet créé avec new et éventuellement détruit avec delete.
main () {
point * adr;
cout << "&& debut main" << endl;
adr = new point(3, 7);
fct(adr);
cout << "&& fin main" << endl;
}
void fct (point * adp) {
cout << "&& debut fct" << endl;
delete adp;
cout << "&& fin fct" << endl;
}point::point(int x, int y) {
cout << "++ appel constructeur" << endl; }

point::~point() { cout << "-- appel destructeur" << endl; }
7.2.Initialisation d'un objet lors de sa déclaration

Avec l‘utilisation systématique des constructeurs (un constructeur crée un emplacement
mémoire pour l‘objet et l‘initialise) C++ ne permet pas de créer un objet sans l‘initialiser en
même temps. Pour créer un objet on doit appeler un constructeur déclaré et défini ou bien le
constructeur par défaut.
Avec la déclaration de la classe suivante :
class Point {
int x ; int y ;
public :
Point(int abs) { x = abs ; y = 0 ; }
...
};
On peut écrire :
point a(3);
a = 3;
Avec la déclaration de la classe suivante :
struct paire { int n ; int p ; } ;
class Point { …
Point(paire q) { x = q.n ; y = q.p; }
};
On peut écrire :
paire s = { 3, 8 } ;
point a(s);
a = s;
7.3.Constructeur par recopie
Cette section reste importante, elle traite du cas où le constructeur d‘une classe possède
un unique paramètre qui est une référence à un objet de la classe. On appelle alors ce
constructeur, le constructeur par recopie. Ce cas est très utilisé en C++ car bien souvent,
dans un programme, on veut dupliquer un objet (afin, par exemple, de travailler sur sa copie et
de garder une sauvegarde). Pour dupliquer l‘objet a dans un objet b, le programmeur écrira
simplement :
Point b = a;
Ou bien :
Point b(a);
On déclare le constructeur par recopie de la manière suivante :
Point (Point &);
Il y a alors 2 cas : soit le programmeur a écrit un constructeur par recopie, soit non.
7.3.1. Il n’existe pas un constructeur par recopie

Les valeurs des membres de l‘objet sont recopiées, une à une, telles quelles. Cette
approche est risquée. Elle ne marche que si les attributs de l‘objet sont des valeurs et pas des
pointeurs. Elle ne marche pas lorsque l‘objet recopié pointe vers d‘autres objets ou structures.
Exemple (qui ne marche pas) :
class vecteur {
int nemarche;
double * adr;
vecteur(int n);
~vecteur();
};
main() {
vecteur a(5);
vecteur b(a);
}
vecteur::vecteur(int n) {
adr = new double[nemarche = n];
cout << "++ " << this << adr <<endl;
}
vecteur::~vecteur() {
cout << "-- " << this << adr <<endl;
delete adr;
}
La création de a est correcte : nemarche vaut 5 et adr pointe sur un tableau de double de
longueur 5. La création de b l‘est presque : nemarche vaut 5 car recopié depuis a, mais adr
pointe aussi sur le tableau de double créé lors de la création de a. Autrement dit, a.adr et b.adr
pointent tous les deux vers le même tableau. Lors de la destruction de a, le destructeur de la
classe vecteur détruit le tableau pointé par adr et lors de la destruction de b, même chose.
Conclusion, le programme se peut se planter lors de la deuxième destruction.
7.3.2. Il existe un constructeur par recopie
La déclaration d‘un constructeur par recopie est du type :
Point (Point &);
Exemple (qui marche) :

vecteur::vecteur(vecteur & v) {
nelement = v.marche;
adr = new double[t];
for (int i=0; i<marche; i++)
adr[i] = v.adr[i];
cout << "&& " << this << adr <<endl;
}
Ici, la création de b est différente de celle de l‘exemple précédent précédent : au lieu de
recopier des valeurs de attributs de a dans ceux de b, le programme exécute le corps du
constructeur par recopie ci-dessus. Il met la valeur de a.marche dans marche, c‘est-à-dire 5,
puis, au lieu de recopier a.adr dans adr, il crée un nouveau tableau de double de taille 5 et
recopie un à un les cases du tableau de double pointé par a.adr dans les cases du nouveau
tableau pointé par adr. Ce qui fait que a.adr et b.adr pointent vers des tableaux différents et
aucun problème ne pourra survenir lors de la destruction de a ou de b.
7.3.3. Les exceptions
Les instructions
point a = point(1, 5);
ou
point a = b;
peuvent avoir des comportements différents de ceux vus ci-dessus.
point a = point(1, 5); sera traitée comme: point a(1,5); on appelle le
constructeur usuel.
Si l‘opérateur = a été redéfini (cf section redéfinition d‘opérateurs) alors point a = b;
appellera cet opérateur au lieu du constructeur par recopie.
7.3.4. Objets membres
Un membre d‘un objet peut éventuellement être un objet.
class Pointcol {
Point p;
int couleur;
Pointcol(int, int, int);
};
Pointcol::Pointcol (int abs, int ord, int coul) : Point(abs, ord) { … }
Le constructeur de Point est appelé avant celui de Pointcol.
Pour les destructeurs, c‘est l‘ordre inverse.
On peut appeler une méthode de la classe Point :
Pointcol pc (1,2,3) ;
pc.p.affiche() ;
8. Héritage
Le concept d'héritage est fondamental en C++ (et en POO en général). Il permet d‘écrire
un programme concisément et il permet la réutilisation de composants logiciels.
La classe dérivée « hérite » de la classe de base.
8.1.1er aperçu de l'héritage en C++
class Point { public:
int x;
int y;
Point(int a, int b) { x = a; y = b; }; ~Point();
void affiche() { cout << "x = " << x << "y = " << y << endl; };
};
class PointCol : public Point {
public:
int couleur;
PointCol(int, int, int); ~PointCol();

void colore(int c) { couleur = c ;};
};
Dans cet exemple, on a défini une classe "dérivée" (PointCol) à partir d'une classe "de
base" (Point).
On dit que la classe PointCol « hérite » de la classe Point.
Cela signifie que les membres de la classe Point sont des membres de la classe PointCol.
8.2.Redéfinition de fonctions membre et de membres
Une fonction membre de la classe dérivée peut avoir la même signature qu'une fonction
de la classe de base. On dit alors que la fonction membre de la classe de base est « Redéfinie »
dans la classe dérivée.
Quand on est dans la classe dérivée, on appelle la fonction de la classe dérivée de façon
habituelle. Si on veut appeler la fonction membre de la classe de base, il faut préciser le nom
de la classe de base :: en préfixe.
Exemple:
class PointCol : public Point { ...
void affiche() {
Point::affiche();
cout << "couleur " << couleur << endl;
};
};
main() { PointCol p(10, 20, 5);
p.affiche();
p.Point::affiche();
p.deplace(2,4);
p.affiche();
p.colore(2);
p.affiche();
}
Pour les membres, c‘est analogue.

Exemple:
class A { ... int a; char b; ... };
class B: public A {float A; ... };
Si b est de type B, b.a fait référence au membre a de type float de la classe B.
On accède au membre a de type int par b.A::a
Le membre a de la classe B s'ajoute à celui de la classe A. Il ne le remplace pas.
Note: on dit REdéfinition et pas SURdéfinition. (Surdéfinition signifie changement de
signature de la fonction au sein d‘une même classe).
8.3.Appel des constructeurs et destructeurs
En fait, les constructeurs et destructeurs obéissent à des règles précises.
On peut transmettre les paramètres du constructeur dérivé au constructeur de base:
class PointCol : public Point { int couleur;

public: PointCol(int x, int y, int c) : Point(x,y) { couleur = c ; };
~Point();
...
};
On peut toujours mettre des arguments par défaut.

Lors de l'appel du constructeur de la classe dérivée, il se produit dans l'ordre:
 appel du constructeur de base,
 exécution du corps du constructeur dérivé.
Lors de l'appel du destructeur de la classe dérivée, il se produit dans l'ordre:

 exécution du corps du destructeur dérivé,
 n appel du destructeur de base.
Exemple de code :
class Point { ...
Point (int abs=0, int ord=0) {
x=abs; y = ord; cout << "++ construc Point " << x << " " << y <<
endl; };
~Point () {
cout << "-- destruc Point " << x << " " << y " endl; };
...
}
class PointCol : public Point { ...
PointCol (int abs=0, int ord=0, int c=1) : Point(abs, ord) {
couleur = c;
cout << "++ construc PointCol " << couleur << endl; };
~PointCol () {
cout << "-- destruc PointCol " << couleur << endl; };
...
}
main () {
PointCol a(10, 15, 3);
PointCol b(2, 3);
PointCol c(12);
PointCol d;
pointCol * p;
p = new PointCol(12, 25);
delete adr;
}
La sortie est :
++ construc Point 10 15
++ construc PointCol 3
-- destruc PointCol 1
-- destruc Point 12 25
8.4.Constructeur par recopie
Si la classe dérivée n'a pas de constructeur par recopie, alors appel du constructeur par
défaut (copie des attributs un à un).
Si la classe dérivée a un constructeur par recopie B(B&b), il n'y a pas forcément d'appel
automatique au constructeur par recopie de la classe de base: on peut le spécifier par B ( B &
b ) : A (b) conversion implicite de b en un objet de la classe A.
8.5.Contrôle des accès
8.5.1. « private » et « public »
Une classe dérivée peut accéder aux attributs publics de la classe de base et appeler les
méthodes publiques de la classe de base. Une classe dérivée n'a pas accès aux membres
privés de la classe de base. Un attribut public (resp. privé) est déclaré avec le mot-clé «
public » (resp. « private »).
Exemple :
class Point {
public:
int x;
private :
int y;
public :
Point(int a, int b) { x = a; y = b; }; ~Point();
};
class PointCol : public Point { public:
int couleur;
PointCol(int, int, int); ~Point();
void colore(int c) { couleur = c };
};
La classe PointCol peut accéder à x et ne peut pas accéder à y.

Les classes utilisatrices U de la classe dérivée D suivent les mêmes règles d‘accès dans la
classe de base que la classe dérivée D.
8.5.2. « protected »
Avec le mot-clé ‗protected’, on fait en sorte que:
La classe dérivée a accès aux membres protégés de la classe de base.
Les classes utilisatrices de la classe dérivée non.
Exemple :
class Point { int x; int y;
public: Point(int a, int b) { x = a; y = b; }; ~Point();
protected:
};
Intérêt du statut protégé:
Les membres protégés sont comparables à des membres privés pour un utilisateur de la
classe et à des membres publics pour la classe dérivée.
Exemple d’appel
#include <iostream>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Point {
public:
int x; int d;
int y;
Point(int a, int b) { x = a; y = b; };
// ~Point();
void affiche() { cout << "Les coordonnees actuelles de a sont " << x <<endl<< "Les coordonnees
actuelles de y sont " << y << endl; };
};
class PointCol : public Point {
public:
int couleur;
PointCol(int, int, int);
//~PointCol();
void colore(int c) { couleur = c; };
};
int main() {
int a, b, da,db;
cout<<"Donner le premier point "<<endl;
cin>>a;
cout<<"Donner le deuxieme point "<<endl;
cin>>b;
cout<<"Donner le deplacement du point a "<<endl;
cin>>da;
cout<<"Donner le deplacement du point b "<<endl;
cin>>db;
Point p(a,b);
p.Point::deplace(da,db); // p.deplace(da,db);
p.Point::affiche(); // p.affiche();
return 0;
}
Un exemple d’exécution
Figure 2.1 : Utilisation de classes et contrôle d‘accès

8.5.3. Mode de dérivation
Le mode de dérivation est le mot-clef qui précède le nom de la classe de base lorsque l‘on
définit une classe dérivée :
class B : private A { ...
La classe dérivée a accès aux membres publics de la classe de base.

Les classes utilisatrices de la classe dérivée non.
On parle de mode de dérivation publique ou privée.
Ne pas confondre mode de dérivation (private ou public) placé avant les {} et statut de
visibilité d'un membre (private, protected et public) entre {}.
Note: les mots-clés private, protected et public peuvent apparaître autant de fois que l'on
veut dans une déclaration de classe.
8.6.L'héritage en général
Cette section relie le vocabulaire employé en C++ avec celui de l‘orienté objet en
général.
Vocabulaire pour deux classes A et B en relation d‘héritage.
Si B hérite de A on dit aussi :
B est dérivée de A C++ A est la classe de base de B
B est un A Objet
B spécialise A A généralise B
B est une classe fille de A A est la classe mère de B
B est une sous-classe de A A est une super-classe de B
B is a A Anglais
On parle de la relation est-un ou de la relation is-a.
Dans le cas ou plusieurs classes hérite les unes des autres, on parle de taxonomie de
classes ou d’arbre d'héritage.
C est un B D est un B E est un B G est un F B est un A F est un A
On dit que C est une descendante de A.
A est une ascendante de C.

Si une dérivation multiple contient une seule dérivation privée, alors elle est privée.
En C++ l‘héritage multiple est possible mais déconseillé.
8.7.Exploitation d'une classe dérivée
Revoir la section « Classes et objets » « Exploitation des .cpp et .h ».
Un mode d'utilisation en plus: l'héritage.
Dans le B.h, on met :
#include "A.h"
8.8.Compatibilité entre objets d'une classe de base et objets d'une classe dérivée
Puisque la relation d‘héritage est une relation forte, on peut se demander si l‘on peut
affecter un objet de la classe de base dans un objet de la classe dérivée ou pas, et inversement.
L‘idée est que tout objet de la classe dérivée est un objet de la classe de base et que C++
fait des conversions implicites de type.
On peut mettre un objet de type dérivé vers un type de base mais pas l‟inverse.
De même :
on peut mettre un pointeur sur objet de type dérivé vers un pointeur sur objet
de type de base et pas l‟inverse.
Si B est une classe dérivée de la classe A et si on a :

A a; B b;
Alors a = b ; est légal alors que b = a ; est illégal.

Pour s‘en convaincre, imaginons que la classe C dérive de la classe A et que l‘on ait :
C c; Puisque c est dans la classe C, il est dans la classe A et donc si on pouvait faire b=a;
on pourrait faire b=c; ce qui est absurde. Donc on ne peut pas faire b=a;
Si on a :
A * pa; B * pb;
Alors pa = pb ; est légal alors que pb = pa ; est illégal.

Par contre, très souvent, dans une classe dérivée, le programmeur sait que le pointeur pa
est de la classe dérivée donc il peut violer la règle avec l‘opérateur de cast en écrivant :
pb = (B*) pa ;
Evidemment, cette opération peut amener des catastrophes si l‘objet n‘est pas de la classe
dérivée B mais d‘une autre classe dérivée C, complètement différente de la classe B.
Le typage des objets est statique en C++. Cela signifie que le type d‘un objet est connu à
la compilation et ne change plus ensuite.
Point p(3, 5); PointCol pc(8,6,2); Point * pa = &p; PointCol * pb = &pc;
pa->affiche() appellera Point::affiche()
pb->affiche() appellera PointCol::affiche()
Mais si on fait : pa = pb; malheureusement pa->affiche() appelle Point::affiche().

Le choix de la méthode à appeler est fait statiquement (c‘est-à-dire par le compilateur).
Par exemple, pa->colore(4); est une instruction illégale.
9. Fonctions virtuelles
Note : Un pointeur sur un type d‘objet peut recevoir l‘adresse de n‘importe quel objet
descendant mais il existe une lacune de taille: avec ce pointeur on ne peut appeler que des
méthodes correspondant au type du pointeur et non pas au type effectif de l'objet pointé. Cette
lacune vient du fait du typage statique des pointeurs : le type des pointeurs est déterminé à la
compilation.
class Point { ... void affiche(); ... }
class Pointcol: public point { ... void affiche(); ... }
Point p;
Pointcol pc;
Point * adp = &p;
adp->affiche();
Appelle la méthode affiche de la classe Point.
adp = &pc;
adp->affiche();
Appelle la méthode affiche de la classe Point aussi bien que adp pointe vers un objet de
type Pointcol. On a un typage statique.
Pour que l'on puisse appeler une méthode de l'objet descendant, il faut que le typage du
pointeur soit déterminé à l'exécution. On parle alors de typage dynamique.
9.1.Les fonctions virtuelles et le typage dynamique
Voici le code C++ ci-dessous :
class Point { ...
void virtual affiche() {
cout << « Point » << endl ;
}…
}
class Pointcol: public Point { ...
void affiche() {
cout << « Pointcol » << endl ;
} ...
}
Point p;
Pointcol pc;
Point * adp = &p;
adp->affiche();
Appelle la méthode affiche de la classe Point.

adp = &pc;
adp->affiche();
A la compilation, le compilateur ne décide pas quelle méthode appeler. Le compilateur

met en place un mécanisme qui lui permettra de décider à l'exécution quelle méthode appeler
en fonction du type de l'objet pointé.
A l'exécution, cette instruction appelle la méthode affiche de la classe Pointcol car adp
pointe vers un objet de type Pointcol. On a une liaison dynamique.
affiche() est une fonction membre virtuelle, le mot-clé ‗virtual’ le spécifie.
Le programme suivant :
Point p;
Pointcol pc;
Point * adp = &p;
adp->affiche();
adp = &pc;
adp->affiche();
a pour sortie :
Point
Pointcol
9.2.Le mécanisme d'identification des objets
Comment fait le compilateur pour implémenter les fonctions virtuelles ?
class point { ...
void virtual deplace();
void virtual identifie(); .... }
class pointcol: public point { ... void identifie(); ... }
Pour une classe comportant au moins une fonction virtuelle, il existe une table des
adresses de ses fonctions membres:
&point::identifie = @1
&point::deplace = @2
&pointcol::identifie = @3
&pointcol::deplace = @1
&point::deplace = &pointcol::deplace
En plus des emplacements mémoires nécessaires à ses membres, tout objet d'une classe
comportant au moins une fonction virtuelle possède un emplacement mémoire pour un
pointeur contenant l'adresse de sa table des adresses des fonctions virtuelles.
A l'exécution le C++ choisit la bonne table.
9.3.Les fonctions virtuelles en général
Les règles suivantes sont liées aux fonctions virtuelles.
1. La redéfinition d'une fonction virtuelle n'est pas obligatoire.
2. Un constructeur ne peut pas être virtuel.
3. Un destructeur peut être virtuel.
10. Templates
Les « templates » (signifie « patron » ou « modèle » en anglais) sont des types
paramétrés. On peut définir un template de fonction ou un template de classe.
10.1.Template de fonctions
Supposons que l‘on veuille généraliser la fonction echange qui échange deux entiers int à
d‘autres types de données ou objets.
Le code de la fonction de base est le suivant :
void echange(int & a, int & b) {
int c = a ;
a=b;
b=c;
}
Il faudrait surcharger la fonction échange avec autant de fonctions echange que de types
de données ou d‘objets sur lesquels appliquer la fonction echange.
C++ propose le mécanisme de template de fonctions.
Le programmeur devra écrire comme suit :
template <class T>
void echange(T & a, T & b) {
Tc=a;
a=b;
b=c;
}
Ainsi, il définit un template de fonctions. A chaque fois que le compilateur C++

rencontrera un appel de la fonction echange pour des données de type Truc, il engendrera le
code de la fonction echange pour le type Truc.
main() { ...
Truc x = 1 ;
Truc y = 2 ;
Echange(x, y) ;
...
}
void echange(Truc & a, Truc & b) { // fonction engendrée
automatiquement
Truc c = a ;
a=b;
b=c;
}
10.2.Template de classes
On peut aussi paramétrer les classes avec des types et/ou des constantes.
template <class T, int N>
class V { …
const int taille = N ;
T*v;
V() { v = new T[N]; }
~V() { delete [] v; }
};
Ici les paramètres sont les types T et la constante N.

Lors de la première déclaration
V<Machin, 4> x ;
le compilateur engendrera la classe

class V<Machin, 4> { …
const int taille = 4 ;
Machin * v ;
V() { v = new Machin[4]; }
~V() { delete [] v; }
};
Bien sûr, les paramètres des templates de classe doivent être soient des types (au sens
large, c‘est-à-dire des types prédéfini du langage ou des classes définies par le programmeur)
soient des constantes (par exemple n dans l‘exemple ci-dessus).
Les déclarations suivantes sont donc correctes :
V<Truc, 10> y;
V<Bidule, 100> z;
Le programmeur peut imbriquer les templates. S‘il veut définir une classe liste de listes
de Truc, il déclare :
Liste<Liste<Truc>> ll ;
10.3.Généricité et généralisation
Avec des templates, on peut définir des classes Liste<Point> ou Liste<Truc>.
Il suffit d‘avoir un patron de classe Liste :
template <class T>
class Liste { ...
void ajouter(T *);
int enlever(T *);
T * premier();
T * prochain();
...
};
Utiliser des templates s‘appelle aussi la généricité ; la généricité est concurrente de la

généralisation.
Inconvénient de la généricité:
Autant de classes Liste<T> que de classes différentes. Taille plus importante du code.
Avantage :
Ça va plus vite à l‘exécution.
Note : La STL est une librairie de templates standards.
11. La classe vector de la Standard Template Library

C++ contient une librairie de patrons standards, écrite par Meng Lee et Alex Stepanov, la
Standard Template Library (STL). L‘idée de la STL est d‘offrir à l‘utilisateur des composants
abstraits dont l‘utilisation est toujours efficace en temps. La conception de ces composants
suit l‘idée qu‘un algorithme, par exemple la recherche dichotomique, est indépendant des
conteneurs, par exemple un vecteur ou une liste. Pour cela, la STL définit des itérateurs, des
fonctions objets (cf surdéfinition d‘opérateurs) ou des adaptateurs. Les itérateurs sont des
pointeurs généralisés, c‘est-à-dire des objets d‘une classe pour laquelle l‘opérateur de
déréférencement * a été surdéfini. Pour résumer, les patrons standards ou «composants» sont
de cinq catégories à savoir:
 les conteneurs, (vector, list, deque, map, set),
 les algorithmes,
 les itérateurs,
 les adaptateurs,
 et les fonctions objets.
Nous recommandons vivement au programmeur C++ confirmé souhaitant utiliser la STL

de lire le tutorial de Johannes Weidl, disponible sur le Web ou le document de référence des
auteurs de la STL. Néanmoins ce paragraphe se fixe l‘objectif limité de décrire l‘utilisation du
template vector de la STL sur un exemple très simple. Cela permet de comprendre le
minimum sur la STL.
Un vector<T> est un vecteur contenant des T. Par exemple, vector<Ballon*> désigne un
vecteur de pointeurs sur des ballons. Pour utiliser un template de vector, il faut mettre
#include <vector>.
Prenons l‘exemple d‘un attribut de classe contenant les adresses des instances d‘une
classe, (ici la classe Ballon).
class Ballon { public:
static vector<Ballon*> * instances; // les instances
…
};
Le type vector<Ballon*> déclare un tableau unidimensionnel contenant des Ballon*. Sa
taille s‘adapte dynamiquement au nombre d‘éléments du vecteur. instances est donc un
pointeur vers un vecteur de Ballon*. Pour insérer une adresse de ballon, il faut faire :
instances->insert(instances->begin(), this);
(Note : l‘insertion est faite au début par choix).
Pour enlever une adresse de ballon de instances, ne connaissant pas sa place dans le
vecteur, il faut faire une boucle:
for (Ballon**b=instances->begin(); b !=instances->end() ; b++)
if (this==*b) { instances->erase(b) ; break ; }
Les méthodes Ballon** begin(), Ballon** end(), insert(Ballon**, Ballon*),
erase(Ballon**) sont définies implicitement par la classe vector de la STL. Ballon** begin()
retourne le premier itérateur (de type Ballon **) du vecteur. Ballon** end() retourne le
dernier. insert(Ballon**, Ballon*) permet d‘insérer un élément à une position (au début dans
l‘exemple ci-dessus) et erase(Ballon**) permet d‘enlever un élément du vecteur connaissant

sa position.
Un itérateur est une variable permettant de parcourir le vecteur ou de désigner une
position dans le vecteur. Son type par défaut est un type pointeur sur le type contenu du
vecteur. Donc le type de l‘itérateur d‘un vecteur de Ballon* est Ballon**. C‘est pourquoi la
variable de la boucle for ci-dessus parcourant le vecteur est de type Ballon**.
Supposons que l‘on rajoute une méthode retournant l‘adresse de l‘instance de la classe
Ballon ayant un nom connu (de type string) , donné en entrée :
class Ballon {public:
static Ballon * getInstance(string);
…
};
Pour écrire son contenu, on utilisera une boucle du style :

for (Ballon**b=instances->begin(); b !=instances->end() ; b++)
if (((Ballon*)*b)->nom==s) return *b ;
return NULL;
12. Surdéfinition d'opérateurs

Cette section présente la surdéfinition d‘opérateurs. Cette partie du C++ n‘est pas
indispensable pour programmer en C++. Elle permet premièrement d‘écrire des classes dont
l‘utilisation suit exactement la syntaxe des opérateurs prédéfinis tels que +, -, * , /, =, >>, <<,
==, etc. De là, elle permet de programmer dans l‘esprit de la STL (Standard Template
Library).
Vocabulaire : Dans la suite, on utilisera indifféremment les mots «surcharge»,
«surdéfinition» et redéfinition. Tout au long de cette section, l‘exemple suivi est la classe
Rationnel.
class Rationnel {
private :
int num ;
int den ;
public :
Rationnel(int n = 0, int d = 1) { num = n; den = d ; }
...
};
12.1.Surcharge de l‘opérateur d‘affectation =
Pour surcharger un opérateur fondamental du C++, par exemple =, on rajoute la
déclaration de
operator= :
Rationnel & operator=(const Rationnel &);
et sa définition :
Rationnel & Rationnel::operator=(const Rationnel & r) {

num = r.num;
den = r.den ;
return *this ;
}
Noter que l‘opérateur = est vu comme une fonction membre de la classe Rationnel dont
le nom est operator=. Cette fonction membre passe ses paramètres (en entrée et en retour) par
référence. Noter que l‘on met const pour que le C++ vérifie que l‘objet r ne soit pas modifié
au cours de la fonction membre. Noter la valeur de retour *this de cet opérateur : on retourne
le déréferencement de this, adresse de l‘objet courant; donc cet opérateur retourne l‘objet
courant.
Sur les exemples suivants, noter la différence entre une initialisation avec un constructeur
par recopie (cf section sur la construction des objets) et une affectation avec la surcharge de
l‘opérateur =.
Rationnel x(22, 7) ; // constructeur défini par l‟utilisateur
Rationnel y(x) ; // constructeur par recopie
Rationnel w ; // constructeur par défaut
w = x ; // affectation
L‘opérateur d‘affectation = est un « bon » opérateur à surcharger car sa syntaxe, de

gauche à droite, suit celle de l‘orienté objet. Dans l‘expression x = y ; x joue le rôle de
l‘instance sur laquelle on appelle la fonction membre et y joue le rôle du paramètre de la
fonction membre.
Cette expression est donc analogue à l‘expression « objet » x. operator= (y) ; .
D‘autres opérateurs ne sont pas « bons » en ce sens, par exemple les opérateurs
arithmétiques.
12.2.Surcharge de l‘opérateur produit *
Prenons l ‗exemple de l‘opérateur produit *. Il y a beaucoup de cas à traiter et de
multiples façons de faire.
Premièrement, on peut ne pas surcharger l‘opérateur * dans la classe Rationnel et utiliser
une simple fonction membre produit :
class Rationnel { ...
Rationnel produit(Rationnel) ; // declaration
} ; ...
Rationnel Rationnel::produit(Rationnel y) { //definition
Rationnel z(num*y .num, den*y.den);
return z ;
}.
..
Rationnel a(3, 4) ;
Rationnel b(9, 5) ;
Rationnel c = a.produit(b) ; // utilisation banale
Si on souhaite avoir une utilisation uniforme avec les types prédéfinis :
Rationnel a(3, 4) ;
Rationnel b(9, 5) ;
Rationnel c = a*b ; // utilisation habituelle
Il suffit de faire comme cela :
Rationnel operator*(Rationnel) ; // déclaration

...
Rationnel Rationnel::operator*(Rationnel y) { //définition
Rationnel z(num*y .num, den*y.den);
return z ;
}
Mais, * étant commutatif (a*b=b*a), on souhaite garder la symétrie entre les deux
opérandes de * et on utilise une fonction non membre produit :
// def a l‟exterieur la classe Rationnel :
Rationnel operator*(Rationnel x, Rationnel y) {
Rationnel z(x.num*y .num, x.den*y.den);
return z ;
}.
..
Rationnel a(3, 4) ;
Rationnel b(9, 5) ; // utilisation symétrique
Rationnal c = a * b ; // avec opérateur non membre
Mais cela ne marche pas encore tout à fait car, operator* étant un opérateur non membre,
il n‘a pas accès aux membres num et den (qui sont des membres privés). Pour pallier à cet
inconvénient sans mettre num et den en membres publiques, il faut mettre cet opérateur en
fonction amie de la classe Rationnel avec le mot-clé friend:
class Rationnel {
private :
int den ;
int num ;
public :
friend Rationnel operator*(const Rationnel&, const Rationnel&) ;
...
};
...
Rationnel operator*(Rationnel & x, Rationnel & y) {
Rationnel z(x.num*y .num, x.den*y.den);
return z ;
} // voilà du C++ pur et dur !
Noter que l‘on met const pour éviter une modification des paramètres dans la fonction et
que l‘on met des références pour éviter les recopies inutiles.
Conclusion : Quand la syntaxe d‘un opérateur ne permet pas de le surcharger en fonction
membre de la classe (pour des raisons pas toujours défendables de symétrie), on le surcharge
en fonction amie de la classe. Le programmeur non soucieux de la symétrie peut faire comme
au début de cette section.
12.3.Surcharge d‘opérateurs de flux >> et <<
On souhaite surcharger >> et <<. Au lieu de faire banalement comme cela :
class Rationnel { ...
void imprimer() ;
...
} ; ...
void Rationnel : :imprimer() {
cout << num << « / » << den;

}...
Rationnel a(3, 4) ;
a.imprimer() ; // utilisation banale
on veut faire comme cela :

class Rationnel {
private :
int den ;
int num ;
public :
friend ostream & operator<<(ostream &, const Rationnel &)
...
} ; ...
ostream & operator<<(ostream & ostr, const Rationnel & x) {
return ostr << x.num << « / » << x.den ;
}
Rationnel a(3, 4) ;
cout << a;
Ici le problème de la surcharge des opérateurs de flux est différent de celui des opérateurs
arithmétiques. Les paramètres de retour et le premier paramètre sont des streams et pas des
Rationnel. Il est impossible de les surcharger comme fonctions membres de la classe
Rationnel. Ici, le programmeur est obligé d‘utiliser les fonctions amies.
Pour surcharger l‘opérateur >> on fait comme cela :
friend istream & operator>>(istream &, Rationnel &)
...
istream & operator<<(istream & istr, const Rationnel & x) {
cout << « numerateur ? » ; istr >> x.num ;
cout << « denominateur ? » ; istr >> x.den ;
return istr;
}
cin >> a;
cout << a;
12.4.Surcharge de l‘opérateur d‘appel (), « fonctions objets »
Cette section décrit la redéfinition de l‘opérateur d‘appel operator() et les «fonctions
objets». Une fonction objet est un objet d‘une classe dont l‘opérateur d‘appel operator() est
redéfini.
Soit par exemple, une fonction de comparaison d‘un entier avec un seuil :
static int seuil = 4 ;
boolean f(int v) { return (v<seuil) ; }
En C, si l‘on veut passer cette fonction en paramètre d‘une autre fonction, on passe
généralement un pointeur sur cette fonction. En C++, on définit cette fonction comme un
objet d‘une classe, ici par exemple, la classe Comparaison :
class Comparaison {
private :
int seuil ;
public :
Comparaison(int s) { seuil = s ; }
boolean operator()(int v) { return (v<seuil) ; }
...
};
Comparaison inferieurAQuatre(4) ; // création de l‟objet fonction
On utilise l‘objet fonction avec son opérateur d‘appel ().

cout << (inferieurAQuatre(3) ? « yes » : « no ») ; // appel
La sortie sera :
yes no no
L‘appel inferieurAQuatre(3) est équivalent à inferieurAQuatre.operator()(3). On peut

ensuite utiliser l‘objet inferieurAQuatre pour le passer en paramètre d‘une autre fonction.
Cette technique est à la base de la STL (Standard Template Library).
13. Les fonctions amies
En POO pure, l‘encapsulation des données est obligatoire. Dans ce cadre, une fonction
membre d‘une classe ou une fonction indépendante ne peut accéder aux données privées
d‘une autre classe.
Afin de rendre accessibles les données privées d‘une classe à une fonction, on déclare
cette fonction amie avec le mot-clé friend.
Exemple :
class Point { int x; int y;
public: Point(int a, int b) { x = a; y = b; };
~Point();
...
friend int coincide(Point, Point);
...
}; ...
int coincide(Point p, Point q) {
if ((p.x==q.x)&&(p.y==q.y)) return 1 ;
else return 0 ;
}
Pour qu‘une fonction membre machin (char, Point) de la classe Hit soit amie de la classe
Point, on écrira :
class Point { ...
friend Hit::machin(char, Point);
...
};
Note : Une fonction peut être amie de plusieurs classes.

Un ensemble de fonctions peuvent être amies d‘une classe. En particulier toute une classe
peut être amie d‘une autre. Pour dire que toutes les fonctions membres de la classe Hit sont
amies de la classe Point, on notera :
class Point { ...

friend class Bidule;
...
};
Les fonctions amies sont utilisées mais rarement. Des exemples sont fournis à la section
pour surcharger les opérateurs *, >> ou <<.
14. Entrées sorties « élaborées »
Ce paragraphe traite des entrées sorties de manière plus approfondie. Les entrées sorties
minimales déjà présentées étaient des entrées sorties formattées. Il existe des primitives de
plus bas niveau que >> et << pour faire des entrées sorties élaborées.
Il existe des classes de flux utilisées pour le traitement de flux de haut niveau, qui héritent
de la classe de base ios à savoir:
istream est-un ios
ifstream est-un istream
istrstream est-un istream
ostream est-un ios
ofstream est-un ostream
ostrstream est-un ostream
iostream est-un istream
est-un ostream
fstream est-un iostream
strstream est-un iostream
et il existe la classe streambuf pour le traitement de flux de bas niveau.

Les o signifient classe de flux de sortie,
Les i signifient classe de flux d‘entrée,
Les f signifient classe traitement de fichiers,
Les str signifient classe pour traitement de chaînes de caractères.
14.1.La classe ios
C‘est la classe de base pour les ios. Son but est de contrôler le tampon correspondant à un
objet flux instancié en extrayant ou en insérant des caractères dedans.
Sa déclaration est :
class ios {
public :
typedef unsigned long fmtflags ; // chaîne de 32 bits
typedef unsigned char iostate ; // chaîne de 8 bits
...
protected :
streambuf* _strbuf // pointe sur le tampon
ostream* _tie // pointe sur ostream lie a istream
int _width // taille du champ de sortie
int _prec ; // précision pour les réels
char _fill ; // bourrage
fmtflags _flags ; // drapeaux
iostate _state ; // état courant
ios(streambuf* _strbuf = 0, ostream* _tie = 0) ;
~ios() ;
...
};
Les constructeurs et destructeurs de ios sont protégés, ce qui signifie que cette classe
n‘est pas instanciable hors de la classe.
Les membres aussi, ils ne sont pas accessibles à un utilisateur hors de la classe.
Un objet flux est une instance d‘une classe dérivée de ios.
Les attributs de ios :
_strbuf relie l‟objet flux à son tampon.
_tie lie un objet d‟entrée (comme cin) à un objet de sortie (comme cout).
_width définit la largeur du champ de sortie
_prec définit le nombre de chiffres après la virgule pour les réels
_fill est le caractère de remplissage utilisé entre la fin de la sortie effective et la
fin du champ de sortie.
_flags et _state sont des chaînes de bits qui contiennent des paramètres booléens.
Pour accéder à ces attributs, ios fournit un ensemble de primitives de lecture publiques :
class ios {
public :
streambuf* rdbuf() const { return _strbuf ; }
ostream* tie() const { return _tie ; }
int width() const { return _width ; }
int precision() const { return _prec ; }
char fill() const { return _fill ; }
long flags() const { return _flags ; }
int rdstate() const { return _state ; }
...
};
Exemple :
main() {
cout << « cout.width() = « << cout.width() << endl ;
cout << « cout.precision() = « << cout.precision() << endl ;
cout << « cout.fill() = [« << cout.fill() << « ] » << endl ;
cout << « cin.flags() = « << oct << cin.flags() << endl ;
cout << « cout.flags() = « << oct << cout.flags() << endl ;
}
Sortie du programme :
cout.width() = 0
cout.precision() = 6
cout.fill() = [ ]
cin.flags() = 20000000001
cout.flags() = 20000000041
La taille du champ de sortie de cout est 0.

La précision sur les réels est 6 chiffres.
Le caractère de remplissage est le blanc.
_skips vaut 1 pour cin ce qui signifie que cin saute les espaces, les tabulations, passages à
la ligne, sauts de page.
ios fournit un ensemble de primitives d‘écriture publiques :

class ios {
public :
int width(int w) ;
int precision(int p) ;
char fill(char c) ;
long flags(long f) ;
...
};
Ces fonctions retournent l‘ancienne valeur et la remplace pour la nouvelle.

Exemple :
main() {
cout.fill(„#‟);
cout.width(10);
cout << «12345 » << endl ;
cout << «12345 » << endl ;
}
Sortie :
#####12345
12345
_fill et _width sont changés pour le premier appel à cout << mais ils reprennent leur
valeur par défaut pour le deuxième appel.
14.1.1. Les drapeaux de format de ios
Les drapeaux de format ont l‘effet suivant si positionné :
01 skipws saute les blancs
02 left sortie justifiée à gauche
04 right … droite
010 internal sortie num. justifiée à droite ; signe ou base justifié à gauche
020 dec base 10
040 oct base 8
0100 hex base 16
0200 showbase préfixe avec la base 0 (octal) 0x (hexa)
0400 showpoint réels avec point
01000 uppercase majuscule
02000 showpos entiers positifs avec +
04000 scientific notation scientifique pour réels
010000 fixed notation « fixée » des réels
020000 unitbuf vidage du flux après chaque insertion
040000 stdio vidage de stdio et stderr après chaque insertion
La fonction flags() positionne les drapeaux à de nouvelles valeurs. Mais elle réinitialise
les drapeaux non spécifiés dans l‘appel…
Exemple :
main() {
int n = 234 ;
long oldf = cout.flags(ios : :hex | ios : :uppercase) ;

cout << n << endl ;
cout.flags(ios : :hex | ios : :showbase) ;
cout << n << endl ;
cout.flags(oldf) ;
cout << n << endl ;
}
EA
0xea
234
Pour positionner un drapeau sans effacer les autres on doit utiliser la fonction setf().
Exemple :
main() {
int n = 234 ;
long oldf = cout.setf(ios : :hex | ios : :uppercase) ;
cout << n << endl ;
cout.setf(ios : :hex | ios : :showbase) ;
cout << n << endl ;
cout.flags(oldf) ;
cout << n << endl ;
}
EA
0xEA
234
Pour remettre à zéro des drapeaux, on utilise unsetf(). On peut remettre à jour des
ensembles de bits :
0160 basefield
016 adustfield
014000 floatfield
Exemple :
main() {
char buffer[80] ;
cin.unsetf(ios : :skipws) ;
cin >> buffer ; cout << « [« << buffer << « ] » << endl ;
int n = 234 ;
cout.setf(ios : :hex | ios : :uppercase | ios : :showbase) ;
cout << n << endl ;
cout.setf(ios : :basefield) ;
cout << n << endl ;
}
Sortie du programme : hello world
[]
[ hello]
[ world]
0XEA
234
14.1.2. La variable d’état de ios
Les variables d‘état de ios sont entre autres :
0 goodbit
01 eofbit
02 failbit
04 badbit
_state est la variable d‘état du flux ; elle est modifiée par une entrée sortie.
On peut lire _state avec rdstate().
Exemple :
main() {
cout << « cin.rdstate() = » << cin.rdstate() << endl ;
int n;
cin >> n ;
cout << « cin.rdstate() = » << cin.rdstate() << endl ;
}
cin.rdstate() = 0
22
cin.rdstate() = 0
Sortie normale du programme :
Exécution normale :
cin.rdstate() = 0
^D
cin.rdstate() = 3
14.2.Les classes istream et ostream
istream définit l‘opérateur de flux >> et cin,
ostream définit l‘opérateur de flux << et cout.
On appelle les entrées sorties faites avec >> ou <<, les entrées sorties formattées car
elles reconnaissent les types de base et les caractères d‘insertion et d‘extraction.
On peut aussi faire des entrées sorties, dites non formattées, avec d‘autres fonctions
membres de la classe istream ou ostream :
Fonctions d‘entrée non formattées
14.2.1. Lecture de caractères avec cin.get()
Exemple :
main() {
char c ;
while ((c=cin.get()) != EOF)
cout << c ;
cout << endl ;
}
Exemple de sortie du programme :

c‟est pas bien de repeter betement
c‟est pas bien de repeter betement
deux fois la meme chose
deux fois la meme chose
^D
Chaque appel à cin.get() lit un caractère et cout << l‘insère dans la sortie. Ces caractères
sont stockés dans le tampon. Celui-ci est vidé à chaque fin de ligne.
^D termine la boucle.
Il existe une autre fonction get dans cin :
istream& get (char& c) ;
Elle renvoie « faux » lorsqu‘elle détecte une fin de fichier.
Exemple :
main() {
char c ;
while (cin.get(c))
cout << c ;
cout << endl ;
}
c‟est encore moins bien de repeter
c‟est encore moins bien de repeter
quatre fois la meme chose
quatre fois la meme chose
^D
Une troisième forme de get est identique à getline.

Exemple :
istream& getline(char* buffer, int n, char delim = „\n‟) ;
main() {
char buffer[80] ;
cin.getline(buffer, 8) ;
cout << « [« << buffer << « ] » << endl ;
cin.getline(buffer, sizeof(buffer)) ;
cout << « [« << buffer << « ] » << endl ;
}
1234567890ABCDEFGH
[1234567]
[890ABCDEFGH]
La fonction ignore avale les caractères du flux d‘entrée.
Exemple :
istream& ignore(int n= 1, int delim = EOF) ;
main() {
int jour, an ;
cout << « entrez la date (jj/mm/aa) : « ;
cin >> jour ;
cin.ignore() ;
cin.ignore(80, „/‟) ;
cin >> an ;
cout << » jour = « << jour « << « , an = 19« << an << endl ;
}
Entrez la date (jj/mm/aa) : 26/2/98
Jour = 28, an 1998
Il existe encore d‘autres fonctions sur cin à savoir :
peek()
putback()
read()
14.2.2. Fonctions de sortie non formatées
Dans ostream, sont définies des fonctions de sortie non formatées.
La fonction put est surdéfinie :
int put(char c) ;
ostream& put(char c) ;
Elles insèrent toutes les deux le caractère c dans le flux de sortie.

Exemple :
main() {
char c ;
while (cin.get(c))
cout.put(c) ;
cout << endl ;
}
La fonction write() possèdent les fonctions inverses de celle de read.

ostream& write(const char * buffer, int n) ;
ostream& write(const unsigned char * buffer, int n) ;
15. Traitement des fichiers

Exemple de code pour écrire dans un fichier :
#include <iostream.h> // definition du flux cout
#include <fstream.h> // definition de la classe ofstream
#include <stdlib.h> // definition de exit
main() {
ofstream fichierSortie(« monFichier.dat », ios : :out) ;
if ( !fichierSortie) {
cerr << « erreur : ouverture fichier impossible... » << endl ;
exit(1) ;
}
char id[9], nom[16] ;
int note ;
cout << « \t1 : « ;
int n = 1 ;
while (cin >> id >> nom >> note) {
fichierSortie << nom << « « << id << « « << note << endl ;
cout << « \t » << ++n << «: « ;
}
fichierSortie.close() ;
}
Exemple de code pour lire dans un fichier :

#include <fstream.h> // definition de la classe ifstream
main() {
ifstream fichierEntree(« monFichier.dat », ios : :in) ;
if ( !fichierEntree) {
exit(1) ;
}
char id[9], nom[16] ;
int note, somme = 0, compte = 0 ;
while (fichierEntree >> id >> nom >> note) {
somme += note ;
++count ;
}
fichierEntree.close() ;
cout << « la moyenne vaut « float(sum)/count << endl ;
}
Exemple de code pour modifier un fichier :
#include <fstream.h> // definition de la classe fstream
main() {
fstream fichierModifie(« monFichier.dat », ios : :in | ios : :out) ;
if ( !fichierModifie) {
exit(1) ;
}
char c ;
while ((c=fichierEntree.get()) != EOF) {
if (islower(c)) {
fichierModifie.seekp(-1, ios : :cur) ;
fichierModifie.put(toupper(c)) ;
}
}
fichierEntree.close() ;
}
III. EXEMPLES DE PROGRAMMATION EN MODE CONSOLE

Comme annoncé dans la première section de ce chapitre, l‘environnement de
développement utilisé en mode console est le Dev-C++. Bien entendu il existe plusieurs
environnements de développement intégrés (EDI) disponibles pour la programmation en
mode console. Dev-C++ se montre plus facile d‘installation et d‘utilisation, d‘où le choix
porté sur ce dernier.
1. Présentation de l‘EDI Dev-C++
L‘icône de l‘EDI Dev-C++ est le suivant :
Pour pouvoir programmer, il va falloir télécharger l‘outil et l‘installer.

1.1.Téléchargement de l‘IDE Dev-C++
L‘on peut télécharger l‘IDE (Integrated Development Environment, en anglais) ou IDE
en fançais sur le site http://www.01net.com/telecharger/windows/Programmation/ . Le clic sur
ce lien vous redirige sur le page suivante.
Figure 2.2 : Un exemple de site de téléchargement de Dev-C++
1.2.Installation de l‘IDE Dev-C++

Le processus d‘installation est relativement simple. Pour installer le logiciel, il s‘agit de
double-cliquer sur l‘exécutable téléchargé précédemment. Ensuite, l‘assistant d‘installation
guide toutes les étapes d‘installation.
1.3.Etude de l‘interface de l‘IDE Dev-C++
L‘interface d‘accueil de Dev-C++ est illustrée par la figure ci-dessous.
Figure 2. 3 : Interface d‘accueil de Dev-C++

Le descriptif des parties numérotées est le suivant :
1- Il s‘agit des menus et des outils de contrôles,
2- La partie où les programmes écrits s‘afficheront sous forme de fichiers ou dossiers,
3- L‘interface d‘édition des programmes,
4- La sortie. Cette interface notifiera au programmeur s‘il y‘a des erreurs de compilation
ou pas dans le code du programme écrit.
Les boutons suivants du menu permettent respectivement de la

gauche vers la droite de « Compiler », de « Exécuter », de « Compiler et Exécuter », de
« Tout reconstruire » et de « Debugger ».
2. Exemple 1- Création d‘un projet avec Dev-C++ : « Projet HelloWorl »
Pour créer un projet « HellowHolrld » avec l‘IDE Dev-C++, suivre les étapes ci-dessous.
Cliquer sur le menu « Fichier » et pointer sur « Nouveau »
Ensuite cliquer sur « Projet » comme illustré sur la figure ci-dessous.
Le clic sur « Projet » donne ce qui suit :
Figure 2.4 : Création d‘un projet, étape 1

Configurer comme indiqué sur la figure ci-dessus.
 Nom : Ici « HelloWorld »,
 Choisir « Console Application »,
 Cocher « Projet C++ »,
 Enfin cliquer sur Ok.
La suite vous invite à choisir l‘emplacement de votre programme. ‗est ce qu‘illustre la figure
ci-dessous.

Choisir un emplacement du projet. L‘on pourra également créer un dossier à cet effet en
se servant des contrôles situés à droite du champ « Enregistrer dans ».
Dans cet exemple, nous choisissons le Bureau et nous créons un dossier « Hello » dans
lequel nous stockons notre projet.
Ce qui donne la figure ci-dessous.

Pour terminer, cliquer ensuite sur « Enregistrer ».

La figure ci-dessus présente le code minimal généré par l‘IDE pour le projet
« HelloWorld » créé.
Le code comprend :
1. Une directive définie par le mot clé « Include »,
2. Un commentaire délimité par /* ….. */,
3. Et la fonction principale « main() » qui retourne un entier « int ».
Il faut noter que la fonction a également des paramètres « int argc, char** argv ».
#include <iostream>
/* run this program using the console pauser or add your own getch, system("pause") or input
loop */
int main(int argc, char** argv) {

return 0;}
Pour nos besoins, nous allons éditer ce code afin de l‘adapter. L‘objectif étant d‘afficher
un message « Salut le Monde » dans la console, il suffit d‘ajouter une ligne de code dans la
fonction « main() » comme ceci :
cout<< „‟Salut le Monde‟‟\n‟‟ ;
Ce qui donne le code ci-dessous :

#include <iostream>
/* run this program using the console pauser or add your own getch, system("pause") or
input loop */
cout<< "Salut le Monde''\n''" ;
return 0;
}
2.1.Compilation
Le lancement de la compilation se fera en se servant des boutons décrits précédemment.
Note : Le programme doit être compilé avant d‘être exécuté !
Avant de compiler, prendre soin d‘ajouter la ligne suivante juste avant la fonction « main() » :
Le code final du projet sera alors :
#include <iostream>
/* run this program using the console pauser or add your own getch, system("pause") or
input loop */
cout<< "Salut le Monde\n" ;
return 0;
}
Il faut également noter que l‘on peut supprimer les paramètres de la fonction « main() ».
Le lancement de la compilation donne la figure ci-dessous :
Figure 2.8 : Création d‘un projet, compilation et exécution

De préférence, il faut renommer le fichier « main.cpp ». Ici, nous le renommons en
« Hello.cpp ».
2.2.Exécution
L‘exécution du programme donne la figure ci-dessous.
Figure 2.9 : Exécution du programme « Salut le Monde », exemple 1

3. Exemple 2- Saisie et somme de deux nombres
Il s‘agit dans cet exemple d‘écrire un programme qui permet de faire la saisie au clavier
de deux nombres entiers et de faire retourner leur somme.
Pour ce faire, nous présentons le code source du programme et le résultat de l‘exécution.
Code du programme :
#include <iostream>
/* run this program using the console pauser or add your own getch,
system("pause") or input loop */
int main() {
cout<<"Salut, nous allons faire la somme de deux nombres dans "<<
"ce programme"<<endl;
int a, b;
int somme;
cout<<"Veuillez donner le premier nombre"<<endl;
cin>>a;
cout<<"Veuillez donner le deuxieme nombre"<<endl;
cin>>b;
somme=a+b;
cout<<"La somme de "<<a<<" et "<<b<<" est "<<somme<<endl;
return 34;
}
Note : La valeur de retour de main (return) est de 34. En effet, si le programme a bien
compilé et exécuté, la valeur numérique qui suit le return sera renvoyée sinon, le programme
renvoie un code d‘erreur.
Cout et cin permettent respectivement de faire l‘affichage à la console et la saisie au
clavier.
La compilation et l‘exécution du programme donne ce qui suit :
Figure 2.10 : Exécution du programme « Somme de deux nombres entiers », exemple 2

CONCLUSION
Ce deuxième chapitre « LES BASES DU LANGAGE C++ ET LA PROGRAMMATION
EN MODE CONSOLE » a présenté dans sa première section les mots clés du langage C++, le
concept de POO. Dans sa deuxième section, il a été présenté les structures de contrôle, les
pointeurs et les références.
Le chapitre III discutera de la programmation des interfaces graphiques en utilisant la
bibliothèque QtCreator.
CHAPITRE III : PROGRAMMATION DES INTERFACES

GRAPHIQUES EN C++ AVEC Qt
INTRODUCTION
Ce troisième chapitre du livre va présenter le développement des interfaces graphiques en
C++ avec l‘IDE Qt en utilisant le framework QtCreator.
Cette partie du document ne constitue pas un cours complet sur Qt ni un cours sur
QtCreator. Il s‘agit une introduction rapide permettant à un programmeur C++ n‘ayant jamais
manipulé Qt de faire en quelques minutes un programme avec une interface graphique.
1. Création d‘un projet
Une fois installé, en utilisant l‘icône QtCreator, l‘on peut lancer l‘application et procéder à
la création d‘un projet de type GUI comme l‘indique la figure ci-dessous (Figure : 3.2).
Cliquer sur le bouton ‗Nouveau projet‘ indiqué par la flèche ci-dessous.
Il s‘en suit une succession d‘écrans vous permettant alors de créer un projet. Dans un
premier temps, il suffit de choisir un nom de projet et de choisir un répertoire de travail.
Attention, ne mettez qu‘un seul projet par répertoire car un projet se compose d‘un ensemble
de fichiers et il est important d‘éviter les conflits.
La figure ci-dessous présente l‘interface d‘accueil en vue de la création d‘un projet.
Figure 3.1 : Interface de création d‘un projet avec l‘IDE Qt

Il est à noter que l‘on pourra utiliser le menu ‗Fichier‘ pour également créer son projet.
La figure ci-dessous permet de choisir le type de projet à créer ; ici un projet de type GUI.
Figure 3.2 : Choix du type de projet à créer

La figure ci-dessous permet de spécifier l‘emplacement et donner un nom au projet en
cours de création.
Figure 3.3 : Nom et emplacement du projet

L‘écran suivant vous permet de modifier d‘une part le nom de la classe principale et par
conséquent les noms des fichiers C++ correspondant. Par défaut :
 mainwindow.cpp
 mainwindow.h
Notons la présence d‘un fichier mainwindow.ui qui correspond au fichier de l‘interface
graphique c‘est-à-dire permettant au générateur d‘interface de fonctionner.
Figure 3.4 : Configuration des noms des différents fichiers de l‘application

Cette étape constitue la dernière étape délicate lors de la création d‘un projet.
2. Structure d‘un projet
Une fois créé, un projet graphique avec Qt se compose de 5 fichiers à savoir:
 les 2 fichiers C++ dont les noms correspondent au projet
 un fichier main.cpp qui correspond au programme principal.
 Le fichier mainwindow.ui qui correspond à l‘interface graphique.
 Le fichier projet Qt nommé ici essai_demonstration.
La figure ci-dessous illustre la composition d‘un projet graphique avec Qt.
Figure 3.5 : Composition d‘un projet Qt

2.1.Le fichier main.cpp
On n‘a vraiment besoin de le modifier que si on souhaite modifier la fenêtre de démarrage
ou bien inclure de nouvelles librairies Qt.
2.2.Les fichiers mainwindow.cpp et mainwindow.h
Ces fichiers devront être souvent modifiés pendant la conception de l‘interface graphique
pour ajouter de nouveaux slots ou signaux et ainsi faire communiquer les objets de l‘interface.
3. Le générateur d‘interface : Exemple 1-Ajout d‘un bouton
Un double-clic sur mainwindow.gui lance automatique le générateur d‘interface illustré

par la figure ci-dessous.
Le générateur permet d‘ajouter des contrôles à l‘interface graphique en cours de
réalisation par des ‗Glisser-déposer‘.
Figure 3.6 : Interface du générateur

3.1.Création d‘un bouton « Quitter »
Ajout d‘un bouton dans la fenêtre.
Dans la section Buttons à gauche de la fenêtre, par un clic gauche de la souris, faire un
glisser-déposer et insérer un bouton dans la fenêtre, par exemple en bas à droite.
Figure 3.7 : Ajout d‘un bouton dans la fenêtre du générateur, étape 1

L‘inspecteur d‘objet affiche alors les caractéristiques de l‘objet bouton qui vient d‘être créé.
Deux propriétés sont importantes :
La propriété objectName correspond au

nom C++ de l‘instance bouton qui vient
d‘être crée. Cette propriété est dans la
section QObject.
La propriété Text dans la section

QAbstractButton qui correspond au texte
affiché sur le bouton.
Modifions cette propriété en « Quitter ».

Le bouton ressemble alors à ce qui suit :
Figure 3.8 : Ajout d‘un bouton dans la

fenêtre du générateur, étape 2
3.2.Ecriture du code de fonctionnement pour le clic sur le bouton

Attacher du code sur l‘événement click sur le bouton.
Pour cela dans le fichier mainwindow.h, créer une nouvelle section nommée « Private
Slots » et définir une procédure nommée par exemple « BoutonQuitter ». C‘est ce qu‘illustre
la figure ci-dessous.

Editer ensuite le fichier mainwindow.cpp.
Il faut inclure dans ce fichier :

 Le corps de la méthode BoutonQuitter,
 Une connexion entre le signal ou événement « click » et la méthode BoutonQuitter.
Cette description est illustrée par la figure ci-dessous.

La méthode « BoutonQuitter » contient un simple appel à la méthode « close » de la
fenêtre.
void MainWindow::BoutonQuitter()
{
this->close();
}
Le lien entre l‘événement « Click » et la méthode se fait par la méthode Connect :

connect(ui->pushButton,SIGNAL(clicked()),this,SLOT(BoutonQuitter()));
Celle-ci se compose de 3 parties principales :

 Le premier paramètre (ui->pushButton) fait référence à l‘object graphique,
 Le deuxième SIGNAL(clicked()) fait référence à l‘événement concerné (ici « clic »),
 Le quatrième crée la connexion entre l‘objet graphique et la procédure (en Qt le lien
s‘appelle un slot).
3.3.Test : Compilation et exécution
Après compilation et exécution, on obtient le résultat suivant avec la fermeture de la
fenêtre sur l‘événement clic du bouton.
Figure 3.11 : Exécution du projet

4. Composition du dossier du travail
En examinant le dossier de travail, on retrouve les différents fichiers du projet ainsi
qu‘un fichier nommé «essai_demonstration.app» sous MacIntosh ou
«essai_demonstration.exe » sous Windows.
Un double-clic sur le fichier lance l‘application. Attention sous Windows, il est
nécessaire que votre variable d‘environnement PATH contienne un lien vers les fichiers .dll
de Qt. Si ce n‘est pas le cas, penser à cliquer sur le poste de travail et à modifier vos
variables d‘environnement.
Cette composition est illustrée par la figure ci-dessous.
Figure 3.12 : Exécution du projet
5. Afficher des messages dans la fenêtre

Créez une fenêtre avec un « Lineedit » et un « textEdit » séparé par un bouton intitulé
« Lire » comme indiqué sur la capture d‘écran ci-dessous.
Ces deux éléments se

trouvent dans la partie ci-
dessous :
Figure 3.13 : Contrôles ‗LineEdit‘ et TextEdit‘

Comme précédemment, déclarer une nouvelle procédure dans le fichier mainwindow.h.
Le fichier mainwindow.cpp doit être modifié comme suit :
Figure 3.14 : Modification du fichier mainwindow.cpp
Ici, l‘on n‘utilise pas les types de données du C++ standard, il faut prendre soin
d‘utiliser les types spéciaux Qt dont en particulier le type QString et non pas le type string
classique de C++.
Le résultat à l‘exécution du programme est illustré par la figure ci-dessous.
Figure 3.15 : Affichage du texte dans l‘interface graphique

On peut constater que le texte du LineEdit est bien ajouté au fur et à mesure dans la
zone de type TextEdit. Nous avons sur cet exemple mis en évidence la différence entre une
zone de type LineEdit et une zone de type TextEdit.
Figure 3.16 : Différence entre ‗LineEdit‘ et ‗TextEdit‘
6. Utilisation d‘une barre de progression.

Ajoutez sur la fenêtre une barre de progression qui se trouve dans la section « Display
Widgets » comme indiqué sur la figure ci-dessous.
Figure 3.17 : Utilisation d‘une barre de progression, étape 1

Ajouter trois (3) boutons afin d‘obtenir une fenêtre comme celle-ci :

Comme précédemment, modifiez le fichier mainwindow.h :
Le code du fichier mainwindow.cpp est modifié comme suit :

La compilation et exécution de ce programme donne ce qui suit:
Figure 3.20 : Résultat de l‘exécution

Cette introduction au framework Qt avec C++ a pour but de permettre à tout débutant de
pouvoir facilement créer des applications avec QtCreator. Pour des concepts évolués en Qt,
veuillez-vous procurer du livre intitulé « Qt et les interfaces graphiques ».
CONCLUSION
Les applications commercialisables sont dans la plupart du temps graphique. Pour
concevoir et réaliser une application graphique dans un langage donné, il utiliser un IDE
(Integrated Development Environnement) approprié. C‘est e effet l‘objectif de ce troisième
chapitre qui a présenté des exemples de création de projets C++ avec le framework Qt. Il a été
présenté également l‘ossature d‘un projet C++ avec Qt et le contenu du dossier du projet après
compilation et exécution.
QtCreator nous simplifie le processus de compilation, qui est habituellement un peu
délicat avec Qt. Tous les éléments d'une fenêtre sont appelés widgets. Les widgets sont
représentés par des objets dans le code. Ainsi, QPushButton correspond par exemple à un
bouton. Lorsque vous diffusez un programme créé avec Qt, pensez à joindre les fichiers DLL
de Qt pour qu'il puisse fonctionner.
CONCLUSION GENERALE
Ce livre s‘adresse aux professionnels en activités, aux chefs d‘entreprise, aux étudiants et
à toute personne désireuse d‘apprendre le langage de programmation orientée-objet (P.O.O)
C++, dans le but de pouvoir mettre en place des applications professionnelles, dynamiques et
de bonne qualité.
Pour bien présenter le contour du langage, ledit livre est constitué de trois (3) chapitres.
Le premier chapitre intitulé « PRESENTATION GENERALE DU LANGAGE C++ ET DU
PARADIGME P.O.O. » présente de manière générale le langage C++, son origine et son
évolution dans sa première section. La deuxième section aborde le paradigme Orienté Objet
(OO). Le deuxième chapitre qui s‘intitule « LES BASES DU LANGAGE C++ ET LA
PROGRAMMATION EN MODE CONSOLE » présente dans la première section tous les
concepts de base du langage C++. Dans la deuxième section, le livre aborde les concepts de la
programmation orientée objet (POO). Dans la troisième section, le livre présente des
exemples de création de projets en mode console. Le troisième chapitre intitulé
«PROGRAMMATION DES INTERFACES GRAPHIQUES EN C++ AVEC Qt » présente la
réalisation des applications graphiques en C++ avec le framework QtCreator de l‘IDE Qt.
En plus des trois chapitres évoqués, le livre comporte également des exercices et corrigés
et un lexique dans le domaine des TIC en général et en particuliers dans le domaine des
langages de programmation.
QUESTIONNAIRE AUX CHOIX MULTIPLES (QCM)

Pour ce QCM, une seule ou plusieurs propositions peuvent être justes par question. Toutes
les réponses doivent être justifiées par l‘apprenant. Il ne suffit pas donc d‘indiquer la ou les
bonne (s) proposition (s).
1. A quoi sert le cout en C++?
a. Le cout sert à l‘initialisation de variables,
b. Le cout sert à créer des chaînes de caractères,
c. Le cout sert à faire la saisie au clavier,
d. Le cout sert à afficher à l‘écran.
2. A quoi sert le cin en C++?
a. Le cin sert à l‘initialisation de variables,
b. Le cin sert à créer des chaînes de caractères,
c. Le cin sert à faire la saisie au clavier,
d. Le cin sert à afficher à l‘écran.
3. A quoi sert la bibliothèque cmath en C++?
a. Elle contient les chaînes de caractères,
b. Elle définit l‘ensemble des entiers et des réels en C++,
c. Elle gère les entrées et les sorties (cin et cout),
d. Elle contient les fonctions mathématiques avancées de C++,
b. Aucune proposition n‘est bonne.
4. A quoi sert le mot new en C++ ?
a. Le new sert à l‘initialisation de variables,
b. Le new sert à créer des chaînes de caractères,
c. Le new sert à faire la saisie au clavier,
d. Le new sert à afficher à l‘écran,
e. Toutes les propositions sont fausses.
5. Quelle (s) ligne (s) correspond (ent) aux mots clés de C++ ?
a. Insert, inline, for, continue, break,
b. While, do, if, template, class, private,
c. Try, case, int, do, outline, char, float,
d. Void, false, default, virtual, typedef,
e. Typedef, true, catch, finally, do, for.
6. Soit la déclaration de chaîne chaîne prenom ci-dessous. Combien de caractères utiles
peut-on y insérer ?
char prenom[25];
a. 25 caractères,
b. 26 caractères,
c. 24 caractères,
d. Toutes les propositions sont fausses.
7. Que fait la fonction strlen(s) sur la chaîne s?
a. Elle retourne la sous-chaîne de s,
b. Elle retourne la longueur de s,
c. Elle convertit la chaîne s en majuscule,

d. Elle convertit la chaîne s en minuscule,
e. Toutes les propositions sont fausses.
8. La fonction strlen() se trouve dans la bibliothèque string.h?
a. Vrai,
b. Faux.
9. Que fait la fonction tolower()?
c. Elle diminue la taille d‘une chaine de caractère,
d. Elle compare deux chaînes de caratcères,
e. Elle convertit une chaîne en minuscule,
f. Toutes les propositions sont fausses.
10. Repérer la bonne liste des fonctions de la bibliothèque ctype.h
a. Tolower(), gets(), strlen(),
b. Toupper(), strcpy(), strcmp(),
c. Tolower(), toupper(),
d. Toutes les réponses sont fausses.
11. Que fait l’instruction exit(1) ?
a. Elle permet de quitter le programme,
b. Elle met fin à l‘exécution d‘une fonction,
c. Elle termine une classe,
d. Toutes les propositions sont fausses.
12. La fonction exit() se trouve dans la bibliothèque stdlib.h
a. Vrai,
b. Faux.
QUESTIONS-REPONSES
1. D 2. C 3. D
4. E 5. B, E 6. C
7. B 8. A 9. E
10. C 11. A 12. A
EXERCICES
EXERCICE 1 : Questions de cours
1. Donner huit (8) types de variables vues en C++.
2. Donner deux syntaxes de déclaration et d‘initialisation d‘une variable en C++.
3. Expliquer le rôle de la méthode main() dans un programme C++.
4. Rappeler l‘opérateur qui permet de faire une affectation d‘une valeur à une variable en
C++. Donner un exemple dans lequel l‘on affecte la valeur 2 à une variable nommée «
maVariable » de type int.
5. Rappeler deux (2) outils d‘un développeur C++.
6. A quoi sert la bibliothèque « cmath » en C++ ?
7. Donner l‘en-tête de la méthode « main » en C++.
EXERCICE 2
Ecrire un programme en C++ qui calcule le périmètre d‘un cercle. Le programme devra
demander la saisie de toutes les entrées.
EXERCICE 3
Ecrire un programme en C++ qui demande à l‘utilisateur la saisie de deux entiers a et b,
calcule et affiche leur somme, produit et différence.
EXERCICE 4
Ecrire un programme en C++ qui affiche dans la console « Bonjour le monde !! ».
EXERCICE 5
Ecrire un programme en mode console en C++ qui multiplie un tableau (une matrice) de
valeurs saisies par l‘utilisateur par un scalaire (multiplicateur x) et affiche les deux tableaux
(matrices).
Exemple d‘affichage (Les valeurs du tableau et le multiplicateur sont à saisir par l‘utilisateur)
EXERCICE 6
Ecrire un programme en C++ qui demande à l‘utilisateur de saisir un nombre entier N et le
programme retourne un triangle isocèle constitué d‘un caractère qui sera définit dans le
programme ou saisi lors de l‘exécution.
Le symbole de dessin du triangle est à choisir par le programmeur.
Exemples d‘affichage pour la valeur de N=20 pour deux symboles différents (* et 9).
EXERCICE 7
Ecrire un programme en mode console en C++ qui vérifie si un verbe saisi par un utilisateur
est du premier groupe ou non.
 Si le verbe saisi n‘est pas du premier groupe, le programme renvoie le message ‗Le verbe
saisi n‘est pas un verbe du premier groupe‘,
 Dans le cas contraire, le programme retourne la conjugaison au présent du verbe saisi.
Exemple d‘exécution du programme (Ici le verbe ‗programmer‘)
EXERCICE 8
Ecrire un programme en mode console en C++ qui demande :
 la saisie des dimensions (L : ligne et C : colonne) d‘un tableau à deux dimensions,
 la saisie des valeurs de ce tableau à deux dimensions,
 Affiche le tableau saisi puis
 Le transforme et l‘affiche sous forme d‘un tableau à une dimension.
Exemple d‘exécution du programme (Ici L=4 et C=2)
EXERCICE 9
Ecrire un programme en C qui calcule le factoriel d‘un nombre entier N saisi au clavier.
EXERCICE 10
Ecrire un programme en mode console en C qui calcule le nombre d‘années pendant

lequel l‘on deviendra 100 millionnaire s‘il dépose chaque année une somme constante dont il
faut saisir au clavier.
Note : Le taux d‘intérêt est fixé à 3,5%,
Le programme devra afficher le nombre d‘années, le solde total en F CFA et le taux d‘intérêt
saisi.
EXERCICE 11
Ecrire un programme en C qui calcule le PGCD (Plus Grand Commun Diviseur) de deux
nombre saisis au clavier
EXERCICE 12
Ecrire un programme en Java qui déclare et initialise le prix unitaire, la quantité et la TVA
(18%) d‘un article. Le programme doit retourner le prix hors taxe (HT), le montant de la TVA
(MTVA) et le montant total toutes taxes comprises (MTTC) de l‘article payé.
EXERCICE 13
Ecrire un programme graphique en Java qui permet de saisir dans trois zones de saisie le prix
unitaire, la quantité et la TVA (18%) d‘un article. Le programme doit retourner dans trois
zones de textes respectivement le prix hors taxe (HT), le montant de la TVA (MTVA) et le
montant total toutes taxes comprises (MTTC) de l‘article payé.
EXERCICE 14
Ecrire un programme en Java qui fait la permutation de deux nombre entiers saisis par
l‘utilisateur et affiche le résultat de l‘opération de permutation.
EXERCICE 15
Ecrire un programme en Java qui fait la somme et affiche le résultat des n premiers éléments
(à partir de 0) d‘un entier saisi au clavier par un utilisateur si le nombre saisi est pair sinon le
programme retournera le nombre saisi lui-même.
EXERCICE 16
Ecrire un programme en Java permettant la résolution de l‘équation du premier degré
suivante : aX + b = 0.
EXERCICE 17
Ecrire un programme en Java qui permet de résoudre l‘équation du second degré suivante :
aX2 + bX + C = 0
EXERCICE 18
Ecrire un programme en Java qui demande à l‘utilisateur de saisir au clavier un nombre. Le
programme calcule et affiche le cumul et s‘arrête si l‘utilisateur saisit un nombre négatif.
Sinon, le programme demande la saisie du nombre suivant.
EXERCICE 19
Ecrire un programme en Java qui demande à l‘utilisateur la saisie d‘un nombre appelé
« valLimite », et ensuite demande la saisie des « valLimite » nombres réels et calcul leur
somme ou leur produit.
EXERCICE 20
Ecrire un programme en Java qui demande à l‘utilisateur de saisir les notes (5 notes) d‘un
étudiant et calcule puis affiche sa moyenne.
CORRIGES PROPOSES DES EXERCICES

Réponse EXERCICE 1 : Questions de cours
1. Donner cinq (5) types de variables vues en C++

Réponse:
Int, char, long, double, float, String, unsigned int, byte, boolean
2. Donner deux (2) syntaxes de déclaration et d‟initialisation d‟une variable en C++.

Réponse :
1. Type nomVariable ; 2. Type nomVariable=valeur ;
nomVariable=valeur ;
3. Expliquer le rôle de la méthode main() dans un programme C++.

Réponse :
Main() est la méthode principale de tout programme C++. Seul le contenu de main() est exécuté. Tout
le programme est compilé mais seul le contenu de main() est exécuté. Tout programme écrit hors de
main() et non appelé dans main() n‟est pas exécuté.
4. Rappeler l‟opérateur qui permet de faire une affectation d‟une valeur à une variable en
C++. Donner un exemple dans lequel l‟on affecte la valeur 2 à une variable nommée «
maVariable » de type int.
Réponse :
 =;
 Int maVariable=2 ;
5. Rappeler deux (2) outils d‟un développeur C++
Réponse :
Dev-C++, Qt (QtCreator).
6. A quoi sert la bibliothèque « String » en C++ ?

Réponse :
Contient les bibliothèques pour la manipulation des chaînes de caractères.
7. Donner l‟en-tête de la méthode « main » en C++.

Réponse:
int main(){
//Instruction
Return 0 ;
}
Réponse EXERCICE 2
Ecrire un programme en C++ qui calcule le périmètre d‟un cercle. Le programme devra
demander la saisie de toutes les entrées.
Réponse :
package exemple.toto.com;
#include <iostream>
#include<conio.h>
#include<cstdlib>
int main() {
double perimetre, diametre;
const double pi=3,14 ;
cout<<"Veuillez donner le diametre"<<endl;
cin>>diametre ;
perimetre=diametre*pi ;
cout<<"Le perimetre est : "<<perimetre<<endl;
return 0;
}
Réponse EXERCICE 3
Ecrire un programme en C++ qui demande la saisie de deux nombres entiers a et b, calcule
et affiche leur somme, produit et différence.
Réponse :
package exemple.toto.com;
#include <iostream>

int main(){
int a, b ;
int somme, produit, difference ;
cout<<"Donner le premier nombre a "<<endl ;
cin>>a ;
cout<<"Donner le deuxieme nombre b "<<endl ;
cin>>b;
somme=a+b ;
produit=a*b ;
difference=a-b ;
cout<<"La somme des deux nombres est "<<somme<<endl ;
cout<<"Le produit des deux nombres est "<<produit<<endl ;
cout<<"La difference des deux nombres est "<<difference<<endl ;
return 0 ;
}
Réponse EXERCICE 4
Ecrire un programme en C++ qui affiche dans la console «Bonjour le monde !!».
Réponse :
package java.test.com;
#include <iostream>

int main(){
cout<<"Bonjour le monde !! "<<endl ;
return 0 ;
}
Réponse EXERCICE 5
Ecrire un programme en mode console en C++ qui multiplie un tableau (une matrice) de
valeurs saisies par l‟utilisateur par un scalaire (multiplicateur x) et affiche les deux tableaux
(matrices).
#include <iostream>
#include<string.h>

int main(){
{
/* Déclarations */
float A[50][50]; /* matrice donnée */
int N, M; /* dimensions de la matrice */
int I, J; /* indices courants */
float X; /* multiplicateur */
/* Saisie des données */

cout<<"Nombre de lignes (max.50) : "<<endl;
cin>>N);
cout<<"Nombre de colonnes (max.50) : "endl;
cin>>M;
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
cout<<"Element[%d][%d] : ",I,J<<endl;
cin>>A[I][J];
}
cout<<"Donner le multiplicateur X : ");
cin>>X;
/* Affichage de la matrice */
cout<<"Matrice donnee : "<<endl;
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
cout <<"%10.2f", A[I][J]<<endl;
// printf("\n");
}
/* Multiplication des éléments de A par X */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
A[I][J] *= X;
/* Edition du résultat */
cout <<"Matrice résultat: "<<endl;

for (I=0; I<N; I++) {
for (J=0; J<M; J++)
cout<<"%10.2f", A[I][J]<<endl;
// printf("\n");
}
return 0;
}
Réponse EXERCICE 6
Ecrire un programme en C++ qui demande à l‟utilisateur de saisir un nombre entier N et le

programme retourne un triangle isocèle constitué d‟un caractère qui sera définit dans le
programme ou saisi lors de l‟exécution.
Le symbole de dessin du triangle est à choisir par le programmeur.
#include <iostream>
#include<string.h>

int main(){
int i, j,N;
char c;
cout<<"Donner le caractere"<<endl;
cin>>c;
cout<<"Donner un entier positif N"<<endl;
cin>>N;
for(i=0;i<N;i++){
for(j=0;j<N-(i+1);j++)
cout<<" ";
for(j=0;j<2*i+1;j++)
cout<<c<<endl;
// printf("\n");
}
return 0;
}
Réponse EXERCICE 7
Ecrire un programme en mode console en C++ qui vérifie si un verbe saisi par un utilisateur
est du premier groupe ou non.
 Si le verbe saisi n‟est pas du premier groupe, le programme renvoie le message „Le verbe
saisi n‟est pas un verbe du premier groupe‟,
 Dans le cas contraire, le programme retourne la conjugaison au présent du verbe saisi.
Réponse :
#include <iostream>
#include<string.h>
int main(){
/*déclaration*/
char verb[20];
/*chaine contenant le verbe*/
char affi[30];
/*chaine pour l'affichage*/
int L;
/*longueur de la chaine*/
/*saisie des donnees*/
cout<<"verbe"<<endl;
cin>>verb;
/*controler s'il s'agit d'un verbe en 'er'* et abstraction au verbe aller*/
L=strlen(verb);
if((verb[L-2]!='e')||(verb[L-1]!='r')|| strcmp("aller", verb)==0)
puts("\a Ce n'est pas un verbe du premier groupe!!!!!!!!!!");
else{
/*couper la terminaison 'er'*/
verb[L-2]='\0';
/*conjuguaisoné*/
affi[0]='\0';
strcat(affi,"je ");
strcat(affi,verb);
strcat(affi,"e");
cout<<affi<<endl;
affi[0]='\0';
strcat(affi,"Tu ");
strcat(affi,verb);
strcat(affi,"es");
puts(affi);
affi[0]='\0';
strcat(affi,"Il ");
strcat(affi,verb);
strcat(affi,"e");
puts(affi);
affi[0]='\0';
strcat(affi,"Nous ");
strcat(affi,verb);
strcat(affi,"ons");
puts(affi);
affi[0]='\0';
strcat(affi,"Vous ");
strcat(affi,verb);
strcat(affi,"ez");
puts(affi);
affi[0]='\0';
strcat(affi,"ils ");
strcat(affi,verb);
strcat(affi,"ent");
puts(affi);
}
return 0;
}
Réponse EXERCICE 8
Ecrire un programme en mode console en C++ qui demande :

 la saisie des dimensions (L : ligne et C : colonne) d‟un tableau à deux dimensions,
 la saisie des valeurs de ce tableau à deux dimensions,
 Affiche le tableau saisi puis
 Le transforme et l‟affiche sous forme d‟un tableau à une dimension.
#include<iostream>
int main(){
const int n=10;
const int m= 100;
int i,j,L,C,M[n][n];
int v[m],k;
cout<<"Donner le nbre de lignes L"<<endl;
cin>>L;
cout<<"Donner le nbre de colonnes C"<<endl;
cin>>C;
cout<<"La saisie de M"<<endl;
for(i=0;i<L;i++)
for(j=0;j<C;j++){
cout<<"Donner M["<<i<<"]["<<j<<"]\n"<<endl;
cin>>M[i][j];
}
cout<<"L'affichage de M a 2 dimensions "<<endl;
for(i=0;i<L;i++){
for(j=0;j<C;j++)
cout<<"\t"<<M[i][j]<<"\t";
printf("\n");
}
cout<<"L'affichage du tableau a 1 dimension "<<endl;
k=0;
for(i=0;i<L;i++)
for(j=0;j<C;j++){
v[k]=M[i][j];
k++;
}
for(k=0;k<L*C;k++)
cout<<"\t"<<v[k];
return 0;
}
Réponse EXERCICE 9
Ecrire une fonction en C qui calcule le factoriel d‟un nombre entier N positif saisi au clavier.
Réponse :
#include<iostream>
int fact(int N){
if(N==1)
return 1;
return fact(N-1)*N;
}
int main(){
int N, P;
do{
cout<<"Donner N"<<endl;
cin>>N;
}
while(N<0);
P=fact(N-1)*N;
cout<<"P= "<<P<<endl;
return 0;
}
Réponse EXERCICE 10
Réponse :
Ecrire un programme en mode console en C qui calcule le nombre d‟années pendant
lequel l‟on deviendra 100 millionnaire s‟il dépose chaque année une somme constante dont il
faut saisir au clavier.
Note : Le taux d‟intérêt est fixé à 3,5%,
Le programme devra afficher le nombre d‟années, le solde total en F CFA et le taux d‟intérêt
saisi.
#include <iostream>
#include<conio.h>
/* run this program using the console pauser or add your own getch, system("pause") or input
loop */
/*Exercice: En combien d'années un homme deviendra-t-il millionnaire s'il investit chaque
année 200.000 F CFA dans une banque à un taux de 3,5% ?*/
int main() {
int nbran=0;
double tva,nouvomontant,ancienmontant=0.0;
// for(int i=0;i<5;i++){
cout<<"Donnee le nouveau montant"<<endl;
cin>>nouvomontant;
cout<<"Donnee la tva"<<endl;
cin>>tva;
while(ancienmontant<100000000){
// montant=(1+tva)*montant;
ancienmontant=(1+tva)*ancienmontant +nouvomontant;
nbran=nbran+1;
}
cout<<"Le nombre des annees pour devenir millionnaire est de: "<<nbran<<" ans"<<endl;
cout<<"Le montant pendant: "<<nbran<<" ans est: "<<ancienmontant<<" F CFA"<<endl<<endl;
// i++}
return 0;
}
Réponse EXERCICE 11
Ecrire un programme en C qui calcule le PGCD (Plus Grand Commun Diviseur) de deux
nombre saisis au clavier
Réponse (Proposition en C très proche du C++)
#include<stdio.h>
#include<conio.h>
main(){
int A,B;
int reste,a,b;
do{
printf("Donner A\n");
scanf("%d",&A);
}
while(!A);
do{
printf("Donner B\n");
scanf("%d",&B);
}
while(!B);
for(a=A,reste=A,b=B;reste;a=b,b=reste)
reste=a%b;
printf("Le PGCD de %d et %d est %d",A,B,a);
getch();
}
Il convient à l‟étudiant de trouver la version C++.
GLOSSAIRE
A P
abstract: signifie qu‘il n‘y a pas d‘implémentation. package: regroupement de diverses classes.
ANSI: American National Standard Institute.
PHP (Hypertext Preprocessor) : Plus connu sous
ARM : The Annotated C++ Reference Manual fut son sigle PHP (acronyme récursif), est un langage
publié en 1990, apportant les bases du futur de programmation libre, principalement utilisé pour
standard.
produire des pages Web dynamiques via un serveur
Attribut : Peut être une variable ou une colonne HTTP, mais pouvant également fonctionner comme
d‘une relation, caractérisée par un nom. n'importe quel langage interprété de façon locale.
B PHP est un langage impératif orienté objet. Ledit
langage a permis de créer un grand nombre de sites
Base de données (BD ou BDD) : Une base de
web célèbres, comme Facebook, Wikipédia, etc. Il
données est un ensemble de tables, ayant pour but
est considéré comme une des bases de la création de
d‘exploiter des informations de façon conviviale et
sites web dits dynamiques mais également des
rapide ou ensemble de données (de l‘organisation)
applications web.
structurées et liées entre elles.
PL/SQL: Procedural Language / Structured Query
 stocké sur support à accès direct (disque), Language. Le langage de requête propre au SGBD
 géré par un SGBD (Système de Gestion de Bases Oracle.
de Données),
P.O.O: Programmation Orientée Objet, il s‘agit
 accessible par un ensemble d'applications.
d‘un paradigme dans le concept de la
C programmation, opposé à la programmation
Clé artificielle : En opposition à une clé naturelle, procédurale ou fonctionnelle.
dans le domaine des bases de données, aussi parfois Private (modificateur): Qualifie un attribut ou un
appelée clé de remplacement (de l'anglais surrogate membre ou fonction membre non accessible de
key) désigne un ensemble de données adjointes aux l‘extérieur par rapport à la classe dans laquelle
données d'une table pour les indexer. il/elle est déclaré (e).
Clé candidate : C‘est un ensemble des données Projection : On ne sélectionne qu‘un ou plusieurs
permettant d'indexer chaque ligne d'une table donnée attributs d‘une relation (on ignore les autres). Par
de manière différenciée. Une même table peut exemple n‘afficher que les colonnes nom et prénom
posséder plusieurs clés candidates distinctes. Une de la table Personnes.
table avec des lignes en doublon ne possède aucune
Propriété : Colonne ou champ d‘une table (voir
clé candidate.
attribut).
Clé étrangère : Dans une base de données
Public (modificateur): Qualifie un attribut ou un
relationnelle, est une contrainte qui garantit l'intégrité
membre ou fonction membre accessible de
référentielle entre deux tables.
l‘extérieur par rapport à la classe dans laquelle
Clé naturelle : C‘est une clé choisie parmi les clés il/elle est déclaré (e).
candidates pour indexer une base.
R
Clé primaire : La clé primaire est un identifiant (ou
Requête : Une requête est composée d‘une ou de
champ ou groupe de champs) qui permet d‘identifier
plusieurs tables permettant de visualiser ou
ou d‘indexer de manière unique un enregistrement ou
une entrée d‘une table. La clé primaire appartient d‘afficher, d‘insérer, de modifier ou de supprimer
nécessairement à l'ensemble des clés candidates. les données dans les tables de la base de données.
CRUD : Create Read Update et Delete (ou Destroy), Une requête est en effet une interrogation adressée
constitue les quatre principales opérations à au serveur de bases de données.
implémenter lors du développement d‘une Requête de Création de table (CREATE
application ou d‘un logiciel. TABLE): Cette requête crée une table à partir des
données qu'elle a extraites dans une ou plusieurs
D
autres tables.
Domaine : Ensemble des valeurs d‘un attribut.
Requête d’Insertion (INSERT) : Cette requête
Enregistrement ou entrée : Voir tuple. permet d‘insérer ou d‘ajouter des lignes ou
G enregistrements dans une table.
GUI : Graphical User Interface, interface graphique Requête de Mise à Jour (UPDATE) : Cette
utilisateur. requête modifie le contenu d'un ou plusieurs champs
d'une ou plusieurs tables. C'est le moyen le plus
GCJ : GNU Compiler for Java est un compilateur
Java qui compile le Java en code natif pour la efficace pour mettre à jour un grand nombre
machine cible. d'enregistrements en une seule opération.
H Requête de Sélection (SELECT) : C'est celle qu'on
utilisera le plus souvent. Elle permet de sélectionner
HTML (HyperText Markup Language) : C‘est le
des enregistrements, de faire des calculs et des
langage de description des pages web.
regroupements. Elles ressemblent beaucoup aux
HTTP (HyperText Transfer Protocol) : C‘est le filtres, mais permettent, en plus, de travailler sur
protocole d‘échange de données entre un client (un plusieurs tables simultanément.
ordinateur d‘un utilisateur) et un serveur web (un
Requête de Suppression (DELETE) : Cette
ordinateur sur lequel est placé (hébergé) la page ou
requête supprime un ou plusieurs enregistrements
site web).
dans une ou plusieurs tables.
I
Requête Suppression des objets (DROP) : Cette
IDE: Integrated Development Environment, pour requête permet de supprimer des objets (table, vue,
environnement de développement intégré en français synonymes, etc.) de la base de données.
est un outil logiciel qui offre la possibilité d‘écrire le
RMI: Java Remote Invocation.
code, de compiler et d‘exécuter un programme écrit
dans un langage donnée. Donc il s‘agit d‘un RTTI : Run-Time Type Information, l'identification
environnement qui regroupe trois (3) fonctions (3 in de type pendant l'exécution. Il s‘agit de l‘une des
1). nouvelles fonctionnalités ajoutées dans le langage
C++ par rapport au langage C.
J
S
JCE : Java Cryptography Extension.
SDK: Software development Kit, c‘est un ensemble
JCP : Java Community Process.
des outils de développement Java plus le JRE.
JDBC : Java DataBase Connectivity constitue l‘une
Sélection : On sélectionne tous les tuples ou bien
des API de persistance en Java. Offre des possibilités
seulement une partie en fonction de critères de
de connexion aux bases de données.
sélection qui portent sur les valeurs des attributs.
JDK : Java Development Kit ou le kit de Par exemple n‘afficher que les lignes de la table
développement Java. Personnes qui vérifient la condition suivante : le
nom ne commence pas par la lettre ‗C‘. Cette
JLS : Java Language Specification.
algèbre est facilement possible avec les commandes
JRE : Java Runtime Environement, environnement de MySQL (ou SQL) (SELECT… FROM…
d‘exécution de programme Java. WHERE…).
JSR : Java Specifications Requests, permet de SGBD : Système de Gestion des Bases de Données.
proposer des ajouts et des changements sur la plate- Il s‘agit d‘un logiciel ou application permettant la
forme Java. création, la gestion et la facilitation d‘accès aux
JVM : Java Virtual Machine, machine virtuelle Java. bases de données. Exemple de SGBD : Oracle,
MySQL, SQL Server, etc.
L
SQL : Structured Query Language / Langage de
LCD : Langage de Contrôle de Données, sous-
requêtes structurées. Ce langage permet d‘interagir
langage SQL qui définit les droits et les rôles d‘accès
avec la base de données en y ajoutant, supprimant,
aux données dans la base de données.
modifiant et en affichant le contenu des tables.
LDD : Langage de Définition des données, l‘un des
STL : Standard Template Library est une sous-
sous-langages SQL qui permet de définir les objets
bibliothèque de la bibliothèque standard en C qui
de la base de données.
met à la disposition du programmeur des outils
LID : Langage d‘Interrogation des Données, sous- puissants comme les collections (conteneurs) et les
langage SQL pour l‘interrogation des données itérateurs.
(tables, …).
T
LMD : Langage de Manipulation des Données, sous- Tables : Une table est une structure que l‘on définit
langage SQL qui propose des ordres pour la afin de recevoir des informations traitant d‘un même
manipulation des données dans la base de données. sujet. Composée de champs, elle définit les règles
M de validation de ceux-ci. A l‘utilisation, elle
contiendra les données rentrées relatives à la table.
MAMP (Mac OS Apache MySQL PHP) : C‘est un
serveur encore appelé MampServer qui intègre le TCP/IP (Transmission Control Protocol/Internet
serveur de base de données MySQL. Il est édité pour Protocol): Protocole de transport des couches 3 et 4
tourner sur les systèmes d‘exploitation Macintosh. du modèle OSI.
MySQL: My SQL (Structured Query Language). TIC : Technologies de l‘Information et de la
communication.
N
NTIC : Nouvelles Technologies de l‘Information et V
de la Communication. VM : Virtual Machine, machine virtuelle en
français.
O
W
OMG : Objet Management Group.
WORA: Write Once, Run Anywhere (écrit une
Oracle : Oracle est un SGBD commercial qui
fois, exécuté partout).
occupe le premier rang dans le classement mondial
de 2017. X
OS : Operating System (SE : Système d‘Exploitation
en français). XML : Extensible Markup Language.

OSI (Opened Systems Interconnection) : Norme Xcode : Outil de développement Java.
réseau normalisée par ISO pour l‘interconnexion des
systèmes ouverts. C‘est aussi le modèle de référence
à sept (7) couches servant de standard pour les
normes réseaux.
BIBLIOGRAPHIE ET WEBOGRAPHIE
 [Deitel et Deitel 2011] (en) P. Deitel, C++ How to program, 20 Hall, 2011, 8e éd.,
1104 p. (ISBN 978-0-132-66236-9).
 [Dawson 2010] (en) M. Dawson, Beginning C++ Through Game Programming, Course
Technology PTR, 2010, 3e éd., 432 p. (ISBN 978-1-435-45742-3).
 Ouvrage pour débutants dont la pédagogie prend acte du fait que le C++ fait tourner la
plupart des jeux vidéo en 2010.
 [Deitel et Deitel 2004] P. Deitel et H. Deitel, Comment programmer en C++, Reynald
Goulet, 2004, 1178 p. (ISBN 978-2-893-77290-5).
 [Delannoy 2001] Claude Delannoy, Programmer en langage C++, Paris,
Eyrolles, 2011, 8e éd., 822 p. (ISBN 978-2-212-12976-2).
 [Delannoy 2007] Claude Delannoy, Exercices en langage C++, Paris,
Eyrolles, 2007, 3e éd., 336 p. (ISBN 978-2-212-12201-5).
 [Géron et Tawbi 2003] Aurélien Géron et Fatmé Tawbi (préf. Gilles Clavel), Pour mieux
développer avec C++ : design patterns, STL, RTTI et Smart Pointers, Paris, Dunod, 2003,
188 p. (ISBN 978-2-100-07348-1).
 [Guidet 2008] Alexandre Guidet, Programmation objet en langage C++, Paris,
Ellipses, coll. « Cours et exercices. », 2008, 364 p. (ISBN 978-2-729-83693-
1, OCLC 221607125, notice BnF no FRBNF41206426).
 [Hubbard 2002] J. R. Hubbard (trad. Virginie Maréchal), C++ [« Schaum's easy outline of
programming with C++ »], Paris, EdiScience, coll. « Mini Schaum's », 2002,
192 p.(ISBN 978-2-100-06510-3).
Pour débutants pressés.
 [Liberty et Jones 2005] Jesse Liberty et Bradley Jones (trad. Nathalie Le Guillou de
Penanros), Le langage C++ [« Teach yourself C++ in 21 days »], Paris,
CampusPress, 2005, 859 p. (ISBN 978-2-744-01928-9).
 [Stephens, Diggins, Turkanis et al. 2006] D. Ryan Stephens, Christopher Diggins,
Jonathan Turkanis et J. Cogswell (trad. Yves Baily & Dalil Djidel), C++ en action [« C++
Cookbook - Solutions and Examples for C++ Programmers »], Paris, O'Reilly, 2006,
555 p. (ISBN 978-2-841-77407-4, OCLC 717532188, notice BnF no FRBNF40170870).
 [Stroustrup 2012] Bjarne Stroustrup (trad. Marie-Cécile Baland, Emmanuelle Burr,
Christine Eberhardt), Programmation : principes et pratique avec C++ : Avec plus de 1000
exercices. [« Programming : principles and practice using C++ »], Paris, Pearson
education, 2012, 944 p. (ISBN 978-2-744-07718-0).
 [Stroustrup 2003] Bjarne Stroustrup (trad. Christine Eberhardt), Le langage C++ [« The
C++ programming language »], Paris, Pearson education, 2003, 1098 p.(ISBN 978-2-744-
07003-7 et 2-744-07003-3).
 [Sutter et Alexandrescu 2005] Herb Sutter et Andrei Alexandrescu, Standards de
programmation C [« C++ Coding Standards: 101 Rules, Guidelines, and Best Practices »],
Paris, Pearson Education France, coll. « C++ », 2005, 243 p. (ISBN 978-2-744-07144-
7 et 2-744-07144-7).
Utlisation des librairies Qt
 Consultez le site de : http://www.qtfr.org/ pour obtenir une aide complète sur les librairies
Qt.
Contacts
Tel: (+228) 97 31 77 52 / 90 47 51 03 / 93 32 77 18
E-mail:formationfacile.hitt.tg@gmail.com
Site web: www.hittechnologie.com
01 BP 1341 Lomé-Togo.
Avec HIT-T SARL U, faites la différence!

18 LIVRE C++ 1ère EDITION

Transféré par

Informations du document

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

18 LIVRE C++ 1ère EDITION

Transféré par

Droits d'auteur :

Formats disponibles

HIT-TECHNOLOGY SARL U: www.hittechnologie.

LANGAGE DE PROGRAMMATION P.O.O.: C++ et Qt

Pour concepteur et développeur d‟applications en C++ et Qt

Formateur en développement applicatif

« L‟avenir de l‟Homme se trouve dans sa manière de penser »

© Tous droits réservés 2017-2020 HIT-T

PRIX : 1 800 F CFA

DANS LA MÊME COLLECTION

1 ARCHITECTURE ET INTERCONNEXION RESEAU

AVEC HIT-T SARL U, FAITES LA

COLLECTION HIT-T SARL U

A QUI S‘ADRESSE CE LIVRE

OBJECTIFS SPECIFIQUES DE CE LIVRE

Table des matières

7. Outils de développement ................................................................................................ 23

5.7. Passage des paramètres dans une fonction ...................................................................................... 35

6. Instructions conditionnelles ............................................................................................ 35

10. Spécificités de C++ surlangage de C ........................................................................... 50

II. PROGRAMMATION ORIENTEE OBJET ........................................................... 54

1.6. Message ........................................................................................................................................... 56

2. Encapsulation des données ............................................................................................. 56

4. Régles d'utilisation des fichiers .cpp et .h ....................................................................... 60

7. Construction, destruction et initialisation d’objets ......................................................... 64

9. Fonctions virtuelles ........................................................................................................ 74

10. Templates ................................................................................................................... 76

10.1. Template de fonctions ..................................................................................................................... 76

11. La classe vector de la Standard Template Library ..................................................... 78

13. Les fonctions amies ..................................................................................................... 83

15. Traitement des fichiers ............................................................................................... 90

III. EXEMPLES DE PROGRAMMATION EN MODE CONSOLE ............................ 92

2. Exemple 1- Création d’un projet avec Dev-C++ : « Projet HelloWorl » ......................... 93

3. Exemple 2- Saisie et somme de deux nombres ................................................................ 97

3. Le générateur d’interface : Exemple 1-Ajout d’un bouton ............................................102

4. Composition du dossier du travail .................................................................................106

5. Afficher des messages dans la fenêtre ............................................................................107

CHAPITRE I : PRESENTATION GENERALE DU LANGAGE C++

(byte code) objet

1.3.Evolutions des langages

Figure 1.1: Evolution des langages informatiques (Source : http ://www.tiobe.com/)

Figure 1.2 : Bjarne Stroustrup, l'inventeur du C++.

 les fonctions lambda (C++11).

 la composition de classes (composition dans un diagramme de classes),

b.f(); // possible car A::f est publique dans B.

Le programme ci-dessus affiche :

Il est aussi possible de définir un nouveau nom pour un namespace :

6.2.2. Définition de classe

 d'effectuer au moment de la compilation des calculs arithmétiques, si et seulement si

 GCC pour GNU Compiler Collection (libre, multilangage et multiplateforme : UNIX,

CHAPITRE II : LES BASES DU LANGAGE C++ ET LA

 String : Une chaîne de caractères, c'est-à-dire un mot ou une phrase.

– pour la première, d‘ajouter ensuite 1 `a la valeur de i (post-incrémentations),

2.5.2. Les opérateurs composites

L‘expression est équivalente à :

Par exemple, l‘expression i += 3 équivaut à i = i + 3.

Alors, si i vaut 3, l‘expression x = i donne à x la valeur 3.0 (conversion entier → réel).

3.6.Formatage des sorties numériques

Cette instruction n‘est utile que si l‘<expression> a un effet de bord.

Une fonction est caractérisée par :

 chaque expression de la <liste d‘expressions> est évaluée,

5.5.Arguments par défaut

5.7.Passage des paramètres dans une fonction

Mécanisme : l‘<expression entière> est évaluée.

Remarque 1 : La partie else <instruction2> est facultative.

int Max(int x, int y) // calcule le maximum de deux entiers