Université 

Sid Mohammed Ben Abdellah
Ecole Nationale des Sciences Appliquées 
Fès

Programmation Orientée Objet 
C++
Pr. Nabil EL AKKAD

Programmation Orientée Objet C++

Intitulé du module
Ecole Nationale des Sciences Appliquées de
Etablissement dont relève le module
Fès (ENSAF)
Département Génie Electrique et Informatique
Département d’attache
(GEI)
Filière , (Semestre d’appartenance du Génie des Télécommunications et Réseaux
module) (S1)
A. U: 2021/2022
 Objectifs du module
• Différencier la programmation orientée objet de la
programmation procédurales ou structuré.

• Comprendre les concepts élémentaires de la programmation

orientée objet (POO);

• Mettre en œuvre les concepts de la POO en langage C++.

• Réaliser des applications avec le langage C++

2
 Description du module 
• Introduction à l'orienté objet;
• Spécificité de C++;
• Classes et objets;
• Propriétés des fonctions membres ;
• Construction, destruction et initialisation des objets ;
• Surdéfinition des opérateurs;
• Héritage simple, multiple et virtuel;
• Templates ;
• Notion de la bibliothèque STL ;
• …
Evaluations : 
• DS,  TPs (colle),   Projets + exposés. 3
 Documentations  
• Petit manuel de survie pour C++ de François Laroussinie, 2004-2005,
http://www.lsv.ens-cachan.fr/~fl/Cours/docCpp.pdf
• Introduction à C++ de Etienne Alard, revu par Christian Bac, Philippe
Lalevée et Chantal Taconet, 2000
– http://www-inf.int-evry.fr/COURS/C++/CoursEA/
• Thinking in C++ de Bruce Eckel, 2003 http://w2.syronex.com/jmr/eckel/
• http://www.stroustrup.com/C++.html
• http://channel9.msdn.com/Events/GoingNative/2013/Opening-Keynote-
Bjarne-Stroustrup
• Aide en ligne :
– http://www.cplusplus.com/doc/tutorial/
– https://www.coursera.org/course/intropoocpp
• Ouvrage :Claude Delannoy: C++ pour les programmeurs
• Livres gratuits en ligne : http://it-ebooks.info/book/1256/
• Aide en ligne : http://www.cplusplus.com/doc/tutorial/ 4
 Problématique de la programmation
 Introduction
• Pour certains, il suffit d’enchaîner des instructions élémentaires pour
parvenir à résoudre n’importe quel problème ou presque.
• Pour d’autres au contraire, il s’agit de produire (au sens industriel du
terme) des logiciels avec des exigences de qualité qu’on tente de
mesurer suivant certains critères, notamment :
– L’exactitude : aptitude d’un logiciel à fournir les résultats voulus,
dans des conditions normales d’utilisation (par exemple, données
correspondant aux spécifications) ;
– La robustesse : aptitude à bien réagir lorsqu’on s’écarte des
conditions normales d’utilisation ; 5
Problématique de la programmation(suite)

– L’extensibilité : facilité avec laquelle un programme pourra être

adapté pour satisfaire à une évolution des spécifications ;
– La réutilisabilité : possibilité d’utiliser certaines parties
(modules) du logiciel pour résoudre un autre problème ;
– La portabilité : facilité avec laquelle on peut exploiter un même
logiciel dans différentes implémentations ;
– L’efficience : temps d’exécution, taille mémoire...

6
 Problématique de la programmation(suite)
 Modularité
• Les critères cités précédemment influencent sur la manière de conception d’un

logiciel, et notamment sur l’architecture logicielle.

• Plusieurs critères ne sont pas respectés si l’architecture d’un logiciel n’est pas claire.

• Dans ces circonstances, un petit changement de spécification peut conduire à des

répercutions importantes sur le logiciel, ce qui impose une lourde charge de travail

pour réaliser des mises à jour.

• En générale, on adopte une architecture assez flexible pour surmonter ce type de

problèmes, qui se base sur les modules.

• Les modules sont des entités indépendantes intégrées dans une architecture pour

produire un logiciel. 7
 De la programmation classique vers la POO

• Les premiers codes informatiques ont été constitués, généralement, d’une

suite d’instructions qui s’exécutent de façon linéaire:
L’exécution commence de la première instruction, du fichier source, et se
poursuit ligne après ligne jusqu’à la dernière instruction du programme.
• Même que cette approche est simple à mettre en œuvre, elle a des limites.
• Les codes monolithiques de ce genre:
 Ne peuvent pas réaliser de grosses applications;
 Ne favorisent plus la réutilisation du programme.
A cause de ces problèmes, une autre approche, radicalement différente, a été
apparue: c’est l’approche procédurale

8
 De la programmation classique vers la POO (suite)
• Approche procédurale ou classique: permet de découper un pg en un
ensemble de procédures ou fonctions. Ces procédures contiennent des
instructions qui ont pour but la réalisation d’un traitement particulier.
Exemples:
Calcul de vitesse d’une voiture
Résolution d’une équation.
Affichage des notes des étudiants
 ...
Dans le cas de cette approche, procédurale, comme C, Pascal, Fortran, un
programme correspond à la collection d’un ensemble de fonctions qui
s’appellent entre elles.

9
 De la programmation classique vers la POO (suite)
• Approche procédurale favorise:
Création d'un programme plus modulaire et structuré;
Possibilité de réutiliser le même code sans avoir à le retaper.
En contre partie, cette approche a également quelques inconvénients:
o Les procédures et les fonctions accèdent à une zone où les données sont
stockées.
- Il y a une dissociation entre les données et les procédures.
Ce qui pose des difficultés et problèmes lorsque l’on veut changer
les structures de données.

o Les fonctions s’appellent entre elles et peuvent agir sur les mêmes données.
ce qui entraine un risque de partage de données: écriture en même temps
10
dans le même fichier.
 De la programmation classique vers la POO (suite)
• La programmation structurée a fait progresser la qualité de la production des
logiciels.
• Mais, ses propres fondements lui imposent des limitations "naturelles". En
effet, la programmation structurée repose sur ce qu’on nomme souvent
"l’équation de Wirth", à savoir :
Algorithmes + Structures de données = Programmes
• Structurer les programmes pour améliorer : l’exactitude, la robustesse,
l’extensibilité et la réutilisabilité.
• En pratique, on s’est aperçu que l’adaptation ou la réutilisation d’un logiciel
conduit souvent à "casser" le module intéressant, et ceci car il est
nécessaire de remettre en cause une structure de données.
• La cause : équation de Wirth, qui découple les données des procédures
(agissant sur ces données).

11
 De la programmation classique vers la POO (suite)

• A cause des problèmes cités précédemment, il y avait apparition d’une

autre façon de programmer: la programmation par objet, ou bien
l’approche orientée objet, début des années 80.
Un code, d’après cette approche, est vu comme un ensemble d’entités
(objets). Lors de son exécution, ces entités collaborent entre elles en
s’envoyant des messages dans un intérêt commun.

Dans ce schéma, on a un lien fort entre les données et les fonctions qui y 12
accèdent.
 Programmation structurée
Quelques conclusions
• Procédural ou structuré, comme le C:
– On définit des fonctions s'appelant mutuellement.
– Chaque procédure, ou fonction, est associée à un traitement particulier
pouvant être décomposé en sous traitements jusqu'à obtenir des fonctions
basiques.
– En général, le procédural travaille sur le verbe ou l'action.
Exemple: pour déterminer la vitesse d’une voiture, le principe du procédural
permet de faire : « DetermineVitesse(Voiture) » partout où cela est
nécessaire. Le code, ayant une référence à une « Voiture », est donc
fondé et dispersé dans l'ensemble des programmes.
• Orienté Objet (OO ):, comme C++
– On manipule uniquement des objets.
– Des ensembles groupés de méthodes et de variables associées à des entités
intégrant ces variables et ces méthodes.
– Le sujet, dans ce cas, est prépondérant: disposant d'un objet « Voiture », on
fait spontanément : Voiture.DetermineVitesse(). Tout le code lié à l'objet «
Voiture » se trouve ainsi regroupé. 13
 POO et programmation structurée
• Avantages de POO:
– POO remplace, peu à peu, le procédural dans les grands programmes, puisqu’il a
plusieurs avantages:
Facilité d'organisation, méthode plus intuitive, réutilisation, possibilité d'héritage,
projets plus faciles à gérer , facilité de correction.
Le principal intérêt de POO est qu’on ne décrit plus par le code des actions à
effectuer de façon linéaire, mais par des ensembles cohérents appelés « objets ».
– POO est facilement concevable, puisqu’il décrit des entités comme il en existe dans
le monde réel.
Alors, l'objet « Voiture » implémentant la méthode « Voiture.accelerer » et
possédant la propriété « Voiture.roue » est conçu facilement et peut être utilisée.
Par exemple:
Dans une simulation de course automobile, on va faire interagir un ensembles
d’objets de type Voiture. Les modèles à objets sont créés pour modéliser le monde
réel.
Dans un modèle à objets: toute entité du monde réel représente un objet et vice
versa. 14
 POO et programmation structurée
(suite)
• Avantages (suite):

– Programmes plus faciles à maintenir.

Cependant, si l’on décide de modifier la structure des

données dans un programme séquentiel, presque tout le

code est à réécrire

– Programmation plus claire : les fonctions sont rattachées à un

type de données.

Modularité accrue -> possibilité de réutiliser le code

15
 Apports de la Programmation Orientée
Objet (POO)
– Programmation Orientée Objet :
Equation de la POO : Méthodes + Données = Objet
Méthode
- Formuler une stratégie de résolution du problème;
- Isoler les objets qui font partie de la solution et identifier les opérations
sur les objets;
- Regrouper, avec chaque objet, les opérations qui lui sont associées;
- Déduire la spécification des modules.
Démarche d’une méthode orientée objet
- Définir le problème;
- Développer une stratégie informelle de résolution;
- Définir les objets et leurs attributs;
- Identifier les opérations sur les objets
- Etablir les interfaces
- Implémenter les objets
16
Répéter ce processus, récursivement, en cas de besoin.
 Apports de la POO (suite)
Les grands principes de la P.O.O. sont les suivants:
– Objet et Classe
– Encapsulation
– Héritage
– Typage
Vérifications de type + stricte
– Polymorphisme
Surcharge de fonctions et des
opérateurs
Références
Gestion mémoire + facile
C++ = C + Entrées/sorties + facile
Classes et héritage
Polymoryhisme
Fonctions amies (originalité)
Programmation générique 17
 Apports de la POO (suite)
Terminologie de base :
Programme : fonction, bloc, variable, constante, type, instruction, opérateur
Fonction: un emplacement mémoire « adresse de début d’un sous programme »,
Bloc : ensemble de définitions de variables et d’instructions délimité par {...},
Variable: un emplacement mémoire, qui peu être dynamique « locale » ou statique
« globale ».
Constante: un emplacement mémoire. C’est le code machine du programme,
Type : définit les caractéristiques d’un ou plusieurs noms.
Nom: identificateur qui représente une fonction, une variable, une constante, …,
Définition: présente les caractéristiques d’un ou plusieurs noms et réserve de la
place mémoire à ceux-ci.
Déclaration (prototype) : présente les caractéristiques d’un ou plusieurs noms,
Classe: type qui regroupant des données et des fonctions et précisant les droits
d’accès à ces derniers,
18
Objet: instance de la classe « variable ».
 Apports de la POO (suite)
Conception par objet
- Dans la conception qui se base sur les données, une réflexion autour des données
conduit à :

 Spécifier les données à manipuler.

 Réaliser, pour chaque type de données, les fonctions qui permettent de les
manipuler.

Donc, on parle ici de l’OBJET.

- Le principe de base P.O.O est fondée sur le concept d’objet:

Un objet est une association des données et des procédures (méthodes)

accédant à ces données.

D’où l’équation de la P.O.O. : Méthodes + Données = Objet 19

 Apports de la POO (suite)
Objet : Un objet est une structure informatique caractérisée par
un état et un ensemble d'opérations, exécutables par cet objet,
qui caractérise son comportement.
Objet = état + comportement (opérations)
Exemple 1:
Fenêtre
position, taille, bordure, titre,
État
couleur,...
Comportement dessiner, déplacer, agrandir...
(Opérations)

Exemple 2:
Fichier
nom, répertoire, protections,
État
contenu, ...
Comportement
ouvrir, fermer, supprimer,
(Opérations) 20
 Apports de la POO (suite)
Notion d’encapsulation
• L’encapsulation des données signifie qu’il n’est pas possible d’agir directement sur les données
d’un objet.

• Il est nécessaire de passer par l’intermédiaire de ses méthodes, qui jouent ainsi le rôle
d’interface obligatoire.

• Les données privées ne peuvent être manipulées que par les méthodes de la classe.
• L’encapsulation des données présente un intérêt manifeste en matière de qualité de logiciel.

• Elle facilite considérablement la maintenance :

Une modification éventuelle de la structure des données d’un objet n’a d’incidence que sur l’objet lui-même:

Les utilisateurs de l’objet ne seront pas concernés par la teneur de cette modification (ce qui n’est pas
le cas avec la programmation structurée).

De la même manière, l’encapsulation des données facilite grandement la réutilisation d’un objet.

21
 Apports de la POO (suite)

Notion de Classe
• En P.O.O. apparaît le concept de classe:
– Qui correspond simplement à la généralisation de la notion de type qu’on
rencontre dans les langages classiques.

• Une classe n’est rien d’autre que la description d’un ensemble

d’objets ayant une structure de données commune et disposant des
mêmes méthodes.
• Les objets apparaissent alors comme des variables d’un tel type
classe.
• En P.O.O., on dit aussi qu’un objet est une "instance" de sa classe.

22
 Apports de la POO (suite)

Exemple 1:
Personne
-Nom : string
-Prenom : string
-Age : int
+affiche() : void
+calculeAge() : int

Exemple 2:
Materiel
-Nom :string
-Prix : double
-Nombre : int
+affiche() : void
+achete() : void 23
 Apports de la POO (suite)

Classe Instances

Personne -Nom : Meknassi

-Nom : string -Prenom :Ali
-Prenom : string -Age :23
-Age : int Instanciation
+affiche() : void -Nom : Kadiri
+calculeAge() : int -Prenom :Hamza
-Age :30
 Apports de la POO (suite)
Notion d’Héritage
• Un autre concept important en P.O.O. est celui d’héritage.
• Permet de définir une nouvelle classe à partir d’une classe existante
(qu’on réutilise en bloc), à laquelle on ajoute de nouvelles données et
méthodes.
• La conception de la nouvelle classe, dite qui "hérite" des propriétés et
des aptitudes de l’ancienne.
• Comme on peut s’en douter, l’héritage facilite largement la réutilisation
de produits existants.

25
 Apports de la POO (suite)
Notion d’Héritage (suite)
 Ce concept permettant d'ajouter des nouvelles fonctionnalités à une classe à
partir de la création d’une sous-classe héritant des propriétés de la classe de
base et à laquelle s’ajoutent des nouvelles propriétés.
 La classe héritée s’appelle sous-classe (classe dérivée) de la classe mère (super-
classe).
 L'héritage permettant à une classe dérivée d'étendre les propriétés de la classe
de base tout en héritant des attributs et des méthodes de cette classe de base.
 L’héritage en C++, permet à une classe soit d’hériter d'une seule classe de base:
on parle d’héritage simple., ou de plusieurs classes: c’est de l’héritage multiple.
 L’héritage en java ne permet à une classe d’hériter que d'une seule classe de
base (héritage simple).
 Apports de la POO (suite)
Notion d’Héritage (suite)
L’héritage permet de définir une nouvelle classe à partir d’une classe
existante, à laquelle on ajoute de nouvelles données et méthodes.

Exemple 1:
Personne
-Nom : string
-Prenom : string
-Age : int
+affiche() : void
+calculeAge() : int

Etudiant Enseignant
-cne : int -ppr: int
+affiche() : void +affiche() : void
 Apports de la POO (suite)
Notion d’Héritage (suite)

Exemple 2:
Materiel
-nom : string
-prix : string
-nombre : int
+affiche() : void
+achete(): void

Telephone Ordinateur
-autonomie : int -µp : string
-4G : bool -frequence : int
-resolution : String -memoire : int
+affiche() : void +affiche() : void
 Apports de la POO (suite)
Notion du Polymorphisme
• En P.O.O, une classe dérivée peut "redéfinir" (modifier) certaines des
méthodes héritées de sa classe de base.
• Cette possibilité est la clé de ce qu’on appelle le polymorphisme:
C’est-à-dire la possibilité de traiter de la même manière des objets de
types différents, pour qu’ils soient tous de classes dérivées de la même
classe de base.
• Plus précisément, on utilise chaque objet comme s’il était de cette classe
de base, mais son comportement effectif dépend de sa classe effective
(dérivée de sa classe de base);
 En particulier de la manière dont ses propres méthodes ont été redéfinies.
• Le polymorphisme améliore l’extensibilité des programmes, en
permettant d’ajouter de nouveaux objets dans un scénario préétabli.
29
 Historique de C++
• 3ème langage le plus utilisé au monde (classements TIOBE de février 2016
http://www.tiobe.com/index.php/tiobe_index)
• JVM (HotSpot) et une partie du noyau de Google Chrome écrits en C++
• En1980 : Première version développée par Bjarne Stroustrup de Bell Labs AT&T
• 1985 Langage C++, parution du livre Bjarne Stroustrup
http://www.research.att.com/~bs/homepage.html
• Appelé à l’origine « Langage C avec classes »
• Devenu une norme ANSI/ISO C++ en juillet 1998 (C++98 - ISO/IEC 14882) – mise à jour
en 2003 (C++03)
– ANSI : American National Standard Institute
– ISO : International Standard Organization
• Nouvelle norme C++ : C++11
– C++11 (C++0x) approuvée par l’ISO en 12/08/2011 et disponible depuis septembre 2011
(norme ISO/CEI 14882:2011)
• C++14 : révision mineure de C++11
– http://electronicdesign.com/dev-tools/bjarne-stroustrup-talks-about-c14
– http://www1.cs.columbia.edu/~aho/cs4115/lectures/14-01-29_Stroustrup.pdf
• Nouvelle mise à jour annoncée pour 2017
• Mise à jour, décembre 2020 (C++ 20) 30
 Historique de C++ (suite)

‐ Le C est inclus (à 99%) dans le C++

‐ Le C++ rajoute des notions de programmation orientée objet :
classe, héritage, polymorphisme… comme en Java
ainsi que des facilités d’écriture (surcharge d’opérateurs…)
31
 Différences entre Java et C++
– C++ : langage compilé / Java : langage interprété par la JVM
– C++ : pas de machine virtuelle et pas de classe de base / java.lang.object
– C++ : "plus proche de la machine" (gestion de la mémoire)
Gestion de la mémoire :
• Java
– Création des objets par alloc.dynamique (new)
– Accès aux objets par références;
– Destruction automatique des objets par le ramasse miette;
• C++
– Allocation des objets en mémoire statique (variables globales), dans la pile
(variables automatiques) ou dans le tas (allocation dynamique),
– Accès direct aux objets par pointeur ou par référence
– Libération de la mémoire à la charge du programmeur dans le cas de l'allocation
dynamique
Autres possibilités offertes par le C++ : Variables globales, compilation
conditionnelle (préprocesseur), pointeurs, surcharge des opérateurs, patrons de
classe template et héritage multiple
32
 POO et C++
Structure de la mémoire:
• La mémoire contient trois zones d’allocation différentes.
• Chaque zone permet de stocker 3 types de variables:
– La pile
– La zone Statique 
– Le tas

33
 POO et C++ (suite)
• La pile
 La pile est un espace mémoire réservé au stockage des variables désallouées
automatiquement..
 La pile comporte les variables déclarées au sein des fonctions ou à l’intérieur
des blocs « {….} »;
 Ces variables s’appellent variables « locales » ou « automatiques »;
 Ces variables sont crées au moment de l’appel de la fonction et supprimées à
la sortie de la fonction. « ou à l’entrée et à la sortie du bloc »;
 Les durées de vie de ces variables est la durée de vie de la fonction ou du
bloc.

34
 POO et C++ (suite)
• La zone statique
 La zone d’allocation statique comporte les variables déclarées à
l’extérieur de toute fonction ou au sein d’une fonction mais avec le
mot clé « static »;
 Ces variables s’appellent variables « globales » ou « statiques »;
 Ces variables sont crées au moment de l’ exécution du programme et
supprimées à sa fin.
 Les durées de vie de ces variables est la durée de vie du programme.

35
 POO et C++ (suite)
• Le tas
 Le tas comprend les variables crées par le programme au moment de son
exécution. C’est de « l’allocation dynamique ».
 Ces variables s’appellent variables « dynamiques »;
 Elle sont crées au moment ou le programme exploite l’opérateur « new »
et supprimées au moment de l’utilisation de l’opérateur « delete ».
 Les durées de vie de ces variables sont alors variables. Elles commencent
à l’exécution du « new » et se termine à l’exécution de « delete ».
 En cas d’oublie de l’appel à « delete », par le programmeur, sur une
variable crée avec « new » , celle‐ci sera supprimée à la fin de l’exécution
du programme. 36
 POO et C++ (suite)
• Certains langages peuvent être conçus (de toutes pièces) pour appliquer à la
lettre ces principes et réaliser la P.O.O. "pure".
– Simula, Smalltalk ou, Java.
• A l’opposé, on peut toujours tenter d’appliquer "une philosophie P.O.O." à un
langage classique (Pascal, C...).
• Le langage C++ se situe à mi‐chemin entre ces deux points de vue. Il a en effet
été obtenu en ajoutant à un langage classique (C) les outils permettant de mettre
en œuvre tous les principes de la P.O.O.
• La solution adoptée par Bajarne Stroustrup a le mérite de préserver l’existant
(compatibilité avec C++, des programmes déjà écrits en C) ;
 Elle permet également une "transition en douceur" de la programmation
structurée vers la P.O.O.
 En revanche, elle n’impose nullement l’application stricte des principes de P.O.O.
37
 Langage compilé
Etapes qui ont lieu avant l'exécution pour un langage compilé comme C++

Fichier 
de  Librairies
code

Programme 
Compilation Code objet Edition de liens
exécutable

Autres code objet
Fichier
d'entête

38
 Langage interprété 
Cas de Java
Avant exécution Exécution

Autres  byte code

Fichier 
Byte code Machine virtuelle 
de code  Compilation
Java (JVM)
Java

javac MaClasse.class java

MaClasse.java

39
 Les commentaires

//…Texte…
 Commence dès // et se termine à la fin de la ligne.
 Sur une seule ligne.
 A utiliser de préférence pour les commentaires généraux.

/* …Texte…*/
 Le texte entre /* et */ est ignoré par le compilateur.
 Peuvent s’étendre sur plusieurs lignes.
 Peuvent être utilisés pour désactiver, temporairement, une zone
de code.
 Les types de bases
• En C++, tout est objet sauf les types de base.
• Il existe plusieurs types de base, à savoir:
–Un type booléen pour représenter les variables ne pouvant prendre
que 2 valeurs (vrai ou faux : 0 ou 1, etc.) : bool avec les valeurs
associées true et false.
–Quelques types pour représenter les caractères : char, unsigned char
–Quelques types pour représenter les entiers de diverses tailles : int,
short int, unsigned short int et long int,…
–Quelques types pour les réelles : float et double, long double
• La taille nécessaire au stockage de ces types est indépendante de la
machine.
– Avantage : portabilité
– Inconvénient : "conversions" coûteuses
 Les types de bases (2)
• Quelques opérations sur les entiers
– les opérateurs d’incrémentation ++ et de
décrémentation et ‐‐
• ajoute ou retranche 1 à une variable
int n = 12;
n ++; //Maintenant n vaut 13
• n++; « équivalent à » n = n+1; n‐‐; « équivalent à » n = n‐1;
• 8++; est une instruction illégale.
• Peut s’utiliser de manière suffixée : ++n. La différence avec la
version préfixée se voit quand on les utilisent dans les expressions.
En version suffixée l’incrémentation ou la décrémentation s’effectue
en premier.
Exemples:
int m=7; int n=7;
int a=2 * ++m; //a vaut 16, m vaut 8
int b=2 * n++; //b vaut 14, n vaut 8
 Les opérateurs

Opérateurs arithmétiques

Symbole Description Exemple

‐ soustraction x‐y
* multiplication 3 *x
Opérateurs
arithmétiques / division 4/2
% modulo (reste de la 5%2
division)

Opérateurs d’affectations

Symbole Description Exemple

= Affectation x=2
‐= Soustraction et x‐=2
Opérateurs affectation
d’affectation
+= Addition et x+=2
affectation
 Les opérateurs (2)

Opérateurs d’incrémentations et décrémentations

Symbole Description Exemple

++ Pré‐incrémentation ++x
Opérateurs ++ Post‐incrémentation x++
d’incrémentations et
‐‐ Pré‐décrémentation ‐‐x
décrémentations
‐‐ Post‐décrémentation x‐‐

Opérateurs relationnels

Symbole Description Exemple

== égal à x==2
< inférieur à x<2
Opérateurs <= inférieur ou égal à x<=3
relationnels > supérieure à x>2
>= supérieur ou égal à x>=3
!= différent de a !=b
 Les opérateurs (3)

Opérateurs logiques

Symbole Description Exemple

&& et a && b
Opérateurs
logiques || ou a ||b
! non !a

Opérateurs bit à bit

Symbole Description Exemple

& et a&b
| ou a|b
Opérateurs ^ ou exclusif a^b
relationnels ˜ non ˜x
<< décalage à gauche a<<3
>> décalage à droite b>>2
 Les structures de contrôle

• Les structures de contrôle classiques existent en C++:

– if, else

– switch, case, default, break

– for

– while

– do, while
 Les structures de contrôle (2)
Structure if
if (expression logique) instruction;

if (expression logique)
{ instruction;
instruction;
...
}
Structure if else
if (expression logique) instruction;
else instruction;

if (expression logique)
{ instruction;
instruction;
...
}
else
{ instruction;
instruction;
...
}
 Les structures de contrôle (3)
Boucle for

for (initialisation; condition ; incrémentation ou décrémentation)

{
instruction_1;
instruction_2;
...
instruction_n;
}

Boucle while

while (expression booléenne)

{
instruction_1;
instruction_2;
...
instruction_n;
}
 Les structures de contrôle (4)
Boucle do while
do
{
instruction_1;
instruction_2;
...
instruction_n;
} while (condition);

Exemple: calcul de la somme des dix premiers entiers positifs.

int somme=0, indice=1;

do{
somme += indice;
Indice++;
} while (indice<=10) ;
 Les structures de contrôle (4)
L’instruction switch : sélectionne un morceau de code parmi
d'autres en se basant sur la valeur d'une expression entière
switch (variable){
case valeur1 : instructions1 ;
case valeur2 : instructions2 ;
…
default : instructions ;
}

Exemples:
char c= “”;
for(int i = 0; i < 100; i++) {
// Donner une valeur à c à chaque itération
switch(c) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y': cout<<" voyelle “<<endl; break;
default: cout<<" Consonne"<<endl; break;
 Les structures de contrôle (5)
L’instruction break : permet de terminer l’exécution d’une boucle.
Exemple :// Impression des nombres premiers entre 2 et 50.
int n = 50;
bool premier = true;
for (int i = 2; i <= n; i++)
{
premier = true;
for (int j = 2; j < i; j++)
{
if (i % j == 0)
{
premier = false;
break;
}
}
if (premier)
cout<<" le nombre“<<i<<" est premier“ <<endl;
}
 Les structures de contrôle (6)

L’instruction continue : permet l’interruption d’une itération en

cours et retourne au début de la boucle avec exécution de la partie
incrémentation.

Exemple : la somme des entiers impairs.

int somme = 0;
for (int i = 0; i < 100; i++)
{
if (i % 2 == 0) continue;
somme += i;
}
 Les tableaux
Les tableaux, en C++, sont des structures pouvant contenir:
- Un nombre fixe d'éléments de même nature.
- Il peut s'agir d'objets ou de primitives.
Tableaux unidimensionnels
Déclaration : type nomTableau [] ; ou type [] nomTableau ;
Exemple : int t[] ; peut aussi s’écrire : int [] t ;
La différence entre les deux formes :
int [] t1, t2 ; équivalent à int t1[], t2[] ;
int t1[], n, t2[] ; // mélange entre tableaux d’entiers et primitive entier

Les éléments d’un tableau peuvent être d’un type primitif ou d’un type
objet:
Point tp [] ; // tp est une référence à un tableau d’objets de type Point
Point a, tp[], b ; // a et b sont des références à des objets de type Point.
tp est une référence à un tableau d’objets de type Point
 Les tableaux (2)
Tableaux unidimensionnels (2)
Création
La création d’un tableau dans C++ est réalisée par l’opérateur new :
type * nomTableau ;
nomTableau = new type [dimension];
Exemple : int *t= new int[50];
Initialisation
Automatique: Chaque élément du tableau est initialisé selon son
type par l'instruction new :
 0 pour les numériques,
 \0 pour les caractères,
 false pour les booléens
 null pour les chaînes de caractères et les autres objets.
Un tableau est un objet possédant l'attribut length : c'est la taille
du tableau.
Exemple :
int t[] = new int[5] ; cout<<"taille de t : " + t.length<<endl ; // affiche 5
 Les tableaux (3)
Exemple : 
#include <iostream> 
using namespace std;
int main() { 
int i; 
int const tailleTableau(10); //taille du tableau 
int tableau[tailleTableau]; //déclaration du tableau 
for (int i(0); i<tailleTableau; i++ ) {
tableau[i]=i*i; 
cout<<"Le tableau ["<<i<<"] contient la valeur "<<tableau[i]<<endl; 
} 
return 0;
}
 Les tableaux (4)
Exemple 2 : 
#include <iostream> 
using namespace std;
int main() { 
int i, taille; 
cout << "Tapez la valeur de taille : ";
cin >> taille; 
int *t; t = new int[taille]; 
for (i = 0; i < taille; i++)
t[i] = i * i;
for (i = 0; i < taille; i++) 
cout << t[i] << endl; 
delete[] t; 
return 0;
}