1

Rappel C++ du Q1

o Structure d’un programme

o Les types de données
o Déclaration, les opérateurs
o Les flux d’entrées/sorties
o Structures conditionnelles
o Structures répétitives (les boucles)
o Les tableaux
o Les pointeurs
o Les fonctions et passage de paramètres
 2
Structure d’un programme
 3
Les types de données

bool (true, false)

char (caractère sur 8 bits)
short (entier sur 16 bits, -32768..32767)
long (entier sur 32 bits, -21474836478..21474836477)
int (entier sur 16 ou 32 bits)
float (réel en simple précision)
double (réel en double précision)
 4
Déclaration

type identificateur[=valeur][, identificateur[=valeur][...]];

• Initialisation à 0
int i=0, j=0; // Déclaration et initialisation de deux entiers à 0
double somme; // Déclaration d’une variable réelle non initialisée

Structure d’un programme

• Suite de blocs : instruction; ou { suite d’instructions }
• Un bloc peut contenir d’autres blocs

Portée d’une variable

{ int i; { int j } i = i+j } // interdit
{ int i; { int j; i = i+ j;} } // autorisé
 5
Les opérateurs

Opérateurs de comparaison
== égalité
!= inégalité
Opérateurs logiques
< infériorité
&& et logique
> supériorité
|| ou logique
<= infériorité ou égalité
! négation logique
>= supériorité ou égalité

Exemple : ( (a < b && a > 0) || (a > b && a == 0) )

 6
Les flux d’entrées/sorties

Flux de sortie prédéfini cout

• Affichage de variables Ex : cout << var;
• Affichage de suite de caractères Ex : cout << "La valeur de" ;
• Affichage de caractère de contrôle Ex : cout << endl; //(Retour à la ligne)
cout << "la valeur de var est égale à " << var << endl;

Flux d’entrée prédéfini cin Ex : int i;

• Lecture de variables float f;
cin >> i >> f
Déclaration des flux standard
Ajout en début de programme #include <iostream>
using namespace std;
 7
Structures conditionnelles

if (ExprL) bloc1 [ else bloc2 ]

Exécution conditionnelle du bloc suivant ou choix entre deux blocs
If (a < b && a > 0) {i = 0;} else {j = 0;}

switch (valeur) {
case constante1: bloc1 break;
..
default: blocd break; }
Branchement conditionnel
 8
Structures répétitives (les
boucles)

for (instruction1; Exprl; instruction2) blocB;

Exécution de l’instruction 1 (initialisation)
Test (évaluation de Expr) : sortie du for si false
Exécution du blocB
Exécution de l’instruction2 (itération) do blocB while (ExprL);
for (int i = 0; i < j; i = i+1) Exécution en boucle de blocB
au moins une fois
k = i;
do
while (ExprL) blocB
{i = i + a}
Exécution en boucle de blocB ex:
while (a < 10)
while (a < 10) {i = i + a;}
 9
Les tableaux

type identificateur[taille]([taille](...));
float vect[100] // déclaration d’un tableau de 100 réels
bool mat[100][50] // déclaration d’une matrice 100X50 booléens

Réservation mémoire au moment de la compilation

• Pas de modification à l’exécution
10
 11
Les pointeurs

Variable contenant une adresse

mémoire
-->Début d’une zone mémoire
--> Adresse mémoire d’une variable
--> Structures de données avancées
(arborescence)

Opérateurs
& : Adresse mémoire d’une variable
* : Valeur de la variable pointée
sizeof : Taille mémoire d’une
variable
 12
Allocation dynamique en C++

type* Identificateur = new type [nbelem];

int i;
float* vect = new float[i] // déclaration d’un vecteur de réel de taille i
// vect est une variable du type référence de float

Réservation mémoire au moment de l’exécution

• Adaptation aux données
• Variables dynamiques
 13
Les fonctions

• En C/C++ tout est fonction, main est une fonction (PRINCIPALE)

• Une fonction peut retourner une valeur, elle sera du même type
• Ou ne rien retourner, elle sera du type void
• Les paramètres sont les entrées de la fonction
14
 15
Passage de paramètres
 16
Passage de paramètre par
référence
 17
Paramètre par défaut
18
 19
Surcharge de fonction
 20
C++ : classes

 Introduction aux Langages Orientés Objets

 Qu’est-ce qu’un objet ?
 Propriétés d'un objet
 Notion d’héritage et de polymorphisme

• Les classes en C++

– Interface de classe
– Implantation
– Constructeur / destructeur
– Héritage / polymorphisme
 21
Langage Orienté Objet : qu’est-ce
qu’un objet ?

• Un objet est une entité informatique comprenant :

– des données membres (ou champs ou attributs ou variables d’instances)
– des fonctions membres (ou méthodes ou routines)
On appelle encapsulation le fait de regrouper des attributs et des méthodes
travaillant sur les attributs au sein d'une même entité.

Encapsulation ---> Capsule ==

• L'accès aux données et méthodes peut être réglementé :

.
Partie privée
Vision interne
Partie publique Vision externe
 22
Objet : exemples (notation UML)

DeuxRoues Nom de la classe

CompteBancaire
m_tailleRoues
Vision Données membres m_numéro
m_nbVitesses Vision
interne ou attributs m_solde
m_couleur interne
m_propriétaire
m_poids Créditer()
Accélérer() Débiter()
Vision Freiner() Fonctions membres
ou méthodes Fermer()
externe ChangerVitesse() Numéro() Vision
GetCouleur() Solde() externe
GetPoids() Propriétaire()
 23
Propriétés d’un objet

o Un objet possède un état, déterminé par les valeurs des

attributs
o Un objet est décrit par une classe : c’est le prototype utilisé
pour créer plusieurs objets présentant des caractéristique
communes.
o Un objet possède une identité : ils sont distingués grâce à
leurs existences inhérentes et non grâce à la description des
propriétés qu'ils peuvent avoir.
Ne pas confondre instance d'objet et classe d'objets
Une instance de classe fait référence à une chose précise
Une classe désigne un groupe de choses similaires
Ex : Le vélo de mon voisin et le mien sont deux instances de la
classe vélo, même s’ils sont strictement identiques
 24
Notion d’héritage

 L'héritage est un principe propre à la POO qui permet de créer une nouvelle classe à
partir d'une classe existante.
 La classe nouvellement créée, dite classe dérivée, contient les attributs et les
méthodes de la classe dont elle dérive, auxquelles s’ajoutent de nouveaux attributs et
de nouvelles méthodes propres à la classe dérivée.

 L’héritage permet donc de définir une hiérarchie de classes :

 La classe de base est une classe générique.

 Les classes dérivées sont de plus en plus spécialisées

classe de base ou classe mère

Deux roues ou classe parente

Sans moteur A moteur

classes dérivées
ou classes filles

Vélo Patinette Moto Scooter Mobylette

25
 26
Notion de polymorphisme

Une classe dérivée peut fournir une nouvelle définition d’une méthode d'une
classe parente car elle peut avoir besoin de réagir différemment à l'appel de cette
méthode.
Cette redéfinition substituera une méthode à une autre : c’est la
spécialisation.

La notion de polymorphisme signifie que, la même opération pouvant se

comporter différemment sur différentes classes de la hiérarchie, il est
possible d'appeler la méthode d'un objet sans se soucier de son type intrinsèque.
Ceci permet de faire abstraction des détails des classes spécialisées d'une famille
d'objet, en les masquant par une interface commune (qui est la classe de base).
 27
Notion de polymorphisme

Velo
DeuxRoues m_typePedale
GetTypePedale()
virtual Accélérer()
m_tailleRoues La fonction Accélérer() n’est pas la
virtual Freiner()
m_couleur même pour un Velo et une Moto. La
virtual ChangerVitesse()
m_poids redéfinition de cette fonction dans
m_nbVitesses chacune des sous-classes entraînera un
Moto comportement différent suivant que le
virtual Accélérer() m_moteur DeuxRoues est un Velo ou une Moto.
virtual Freiner() m_boiteVitesse
virtual ChangerVitesse() FairePlein()
GetCouleur() AllumerClignotant()
GetPoids() virtual Accélérer()
virtual Freiner()
virtual ChangerVitesse()
28
 Classe : interface 29

C’est la description de la structure interne de la classe

class Ellipse
{
• Visibilité des membres :
Vision protected : – public : membres accessibles à tous
interne float m_cX, m_cY; – private : membres accessibles à
float m_a, m_b; partir de la classe ; accès impossible
par l’extérieur
public : – protected : membres accessibles à
Vision void deplace(float dx, float dy); partir de la classe et des classes
externe void zoom(float z);
dérivées ; accès impossible par
l’extérieur
float surface();

};

NB : dans cet exemple, on a choisi de représenter l'ellipse en interne à la classe par les coordonnées de
son centre (cX, cY), par son grand axe a et par son petit axe b.
 Classe : implantation 30

Interface de la classe Ellipse définition des méthodes associées

void Ellipse::deplace(float dx, float dy)
class Ellipse {
{ m_cX += dx;
m_cY += dy; Opérateur
protected : } de portée
float m_cX, m_cY;
void Ellipse ::zoom(float z)
float m_a, m_b; {
public : m_a *= z;
m_b *= z;
void deplace(float dx, float dy);
}
void zoom(float z);
float surface(); float Ellipse ::surface()
{
}; return 3.14 * m_a * m_b / 4.;
}
 Classe : instanciation 31

class Ellipse
{
protected : Instancier une classe permet de créer un objet
float m_cX, m_cY; (analogue à une déclaration de variable)
float m_r;
public : Instanciation statique de
void deplace(float dx, float dy);
l’objet e, e étant une
int main() variable de type Ellipse
void zoom(float z);
float surface();
{
}; Ellipse e;
void Ellipse::deplace(float dx, float dy)
{ e.deplace(50, 0);
m_cX += dx;
m_cY += dy;
Accès aux float s = e.surface();
membres
}
par le "." e.zoom(1.5);
void Ellipse::zoom(float z)
{
m_a *= z;
m_b *= z;
e.m_cX = 30; // Impossible
} e. deplace(20); // Impossible
float Ellipse::surface()
{ }
return 3.14 * m_a * m_b / 4.;
}
 32
Organisation (usuelle) des fichiers : Les conventions

• Par convention, l'extension d'un fichier contenant du code C est .cpp, .c++ , .cc , .cxx ou .C
• L'extension d'un fichier de déclarations, appelé header, est .h
• Par convention, on crée un fichier .cpp et un .h par classe, chaque fichier ayant le nom de la classe en minuscule.
ellipse.h ellipse.cpp main.cpp
#include “ellipse.h” #include "ellipse.h"
class Ellipse
void Ellipse::deplace(float dx, float dy) int main()
{
{ {
protected : m_cX += dx; Ellipse e;
float m_cX, m_cY; m_cY += dy;
float m_a, m_b; } e.deplace(50, 0);
public : void Ellipse ::zoom(float z) float s = e.surface();
{ e.zoom(1.5);
void deplace(float dx, float dy);
m_a *= z;
void zoom(float z); m_b *= z; return 0;
float surface(); } }
}; float Ellipse :: surface()
{
return 3.14 * m_a * m_b / 4.;
}

Par convention, les noms de classe commencent par une majuscule, les données membres par _ ou
m_, les fonctions membres par une minuscule.
 33
Constructeurs de classe

 Le constructeur est une méthode qui sert à initialiser les attributs de

l’objet
 Systématiquement appelé quand un objet est instancié.
 N’a pas de type de retour
 Porte le nom de la classe

 Une même classe peut avoir plusieurs constructeurs

 34
Constructeurs de classe

o Constructeurs particuliers :
o constructeur par défaut
o Ne contient aucun argument
o Automatiquement généré si aucun constructeur n’est
défini
o A définir explicitement dans le cas contraire
o constructeur de copie
o Contient comme argument un objet du même type
o Sert à créer des clones d’objets
o Automatiquement généré par le compilateur (copie
membre à membre) mais pas toujours satisfaisant
 Constructeurs de classe : exemple 35

ellipse.h ellipse.cpp main.cpp

class Ellipse #include “ellipse.h” #include "ellipse.h"

{
public : Ellipse::Ellipse() int main()
Ellipse(); // Constructeur par défaut { {
Ellipse(float x, float y, float a, float b); m_cX = m_ cY = 0; Ellipse e1;
Ellipse(const Ellipse & e); m_a = m_b = 1; Ellipse e2(2.5, 6.5, 12, 15);
} Ellipse e3(e1); // e3 est un clone de e1
protected : Ellipse e4 = e1; // e4 est un clone de e1
float m_cX, m_cY; Ellipse::Ellipse(float x, float y, float a, float b) : return 0;
float m_a, m_b; m_ cX(x), m_ cY(y), m_a(a), m_b(b) }
{
public : }
void deplace(float dx, float dy);
void zoom(float z) ; Ellipse::Ellipse(const Ellipse & e)
float surface() ; {
}; m_ cX = e. m_ cX;
m_ cY = e. m_ cY;
m_a = e.m_a ;
m_b = e.m_b;
}

void Ellipse::deplace(float dx, float dy)

{
m_ cX += dx; m_cY += dy;
}

etc …
Destructeur de classe 36

o Fonction membre systématiquement appelée juste avant la

destruction d’un objet
o Porte le nom de la classe et est précédé de ~
o Pas de type de retour
o Pas d’arguments
o Un seul par classe
o Permet de libérer les ressources
 37
Destructeur de classe

ellipse.h ellipse.cpp prog.cpp

#include “ellipse.h” #include "ellipse.h"
class Ellipse
{ Ellipse::Ellipse() int main()
public : { {
Ellipse(); // Constructeur par défaut m_cX = m_ cY = 0; Ellipse e;
Ellipse (float x, float y, float a, float b); m_a = m_b = 1; Ellipse* pE = new Ellipse(2.5, 6.5, 12, 15);
Ellipse(const Ellipse & e); }
~Ellipse(); // Destructeur delete pE; // appelle le destructeur pour pE
etc …
protected : return 0;
float m_cX, m_cY; Ellipse::~ Ellipse()
float m_a, m_b; { // Le destructeur est implicitement appelé pour e.
// Libération des ressources }
public : }
void deplace(float dx, float dy);
void zoom(float z); void Ellipse::deplace(float dx, float dy)
float surface(); {
}; m_cX += dx; m_cY += dy;
}

etc …
 38
La notion d’Héritage

L’héritage permet de spécialiser une classe en définissant une relation du

type « est une sorte de ».

Un cercle est une spécialisation d'une ellipse, il en possède les propriétés, en

plus d'autres qui lui sont spécifiques. On dérive donc la classe Cercle de la
classe Ellipse.

Forme

Ellipse Rectangle

Cercle Carre
 39
La notion d’héritage
(Inheritance)
ellipse.h cercle.h prog.cpp
class Ellipse #include “ellipse.h” #include "cercle.h"
{
public : class Cercle : public Ellipse int main()
Ellipse(); { {
Ellipse (float x, float y, float a, float b);
public : Cercle c(5, 5, 15);
Ellipse(const Ellipse & e); Cercle(); c. affiche();
~Ellipse();
Cercle (float x, float y, float diametre); return 0;
protected : ~ Cercle(); }
float m_cX, m_cY; public :
float m_a, m_b; virtual void affiche();
};
public :
void deplace(float dx, float dy);
void zoom(float z);
cercle.cpp
float surface(); #include <iostream.h>
Autorise la
virtual void affiche(); Le constructeur de la classe dérivée
redéfinition de #include “cercle.h”
}; appelle généralement un des
la fonction dans
les classes Cercle::Cercle() : public Ellipse() constructeurs de la classe de base.
dérivées {
ellipse.cpp
}
#include <iostream.h> Cercle::Cercle(float x, float y, float diametre) : public Ellipse( x, y, diametre, diametre)
{
void Ellipse::affiche() }
{
void Cercle::affiche()
std::cout << "Ellipse de grand axe " << m_a;
{
std ::cout << " et de petitt axe " << m_b << "\n";
} std::cout << "Cercle de rayon " << m_a / 2 << "\n";
}
 Polymorphisme 40

ellipse.h cercle.h
class Ellipse #include “ellipse.h” main.cpp
{
#include " cercle.h"
public : class Cercle : public Ellipse
Ellipse(); {
int main() La fonction deplace() n’est pas
Ellipse (float x, float y, float a, float b); public :
{ redéfinie dans la classe Cercle,
Ellipse(const Ellipse & e); Cercle();
Ellipse e(0, 0, 8.5, 10.2); appelle celle de Ellipse.
~Ellipse(); Cercle (float x, float y, float d);
~ Cercle(); e.deplace(-1, 1); La fonction affiche() est redéfinie
protected : public : e.affiche(); dans la classe Cercle, appelle celle
float m_cX, m_cY; virtual void affiche(); de Cercle.
float m_a, m_b; }; Cercle c(-2.5, 2.5, 7,4);
c.deplace(0.5, 1.5);
public : c. affiche();
void deplace(float dx, float dy); cercle.cpp Appelle la fonction affiche()
void zoom(float z); de la classe Ellipse.
#include “cercle.h” Ellipse *p1;
float surface();
virtual void affiche(); p1 = new Ellipse;
}; Cercle::Cercle() : public Ellipse() p1 ->affiche();
{
} Ellipse *p2; Si la fonction affiche() est
p2 = new Cercle; virtuelle et est redéfinie dans
Cercle::Cercle(float x, float y, float d) : p2->affiche(); la classe Cercle, appelle celle
ellipse.cpp public Ellipse( x, y, d, d)
de Cercle bien que le pointeur
{
#include <iostream.h> return 0; soit de type Ellipse. C'est le
}
} mécanisme de polymorphisme
void Ellipse::affiche() d'héritage.
void Cercle::affiche()
{ {
std::cout << "Ellipse de grand axe " << m_a; std::cout << "Cercle de rayon ";
std ::cout << " et de petit axe " << m_b << "\n"; std::cout << m_a / 2 << "\n";
} }
 41
Vocabulaire

 Variable : associe un nom (un symbole) à une valeur qui peut éventuellement varier au
cours du temps ; une variable est d’un type donné, défini une fois pour toute (type
prédéfini dans le langage ou créé par le développeur).
 Encapsulation : regroupement des variables et des fonctions au sein d'une même entité
appelée « classe ».
 Classe : prototype qui définit des attributs et des méthodes communes à tous les objets
d'une certaine nature.
 Interface de classe : description de la structure interne de la classe incluant une liste des
données membres et le prototype des fonctions membres ; dans un « .h ».
 Implantation de classe : définition (code) des fonctions déclarées dans l’interface de
classe ; dans un « .cpp ».
 Instanciation d’un objet : permet de créer un objet d’un type donné ; analogue à une
déclaration de variable.
 Héritage : permet de définir une hiérarchie de classe, chaque classe fille héritant des
méthodes et des données de son/ses antécédent(s).
 Polymorphisme : deux objets héritant une même méthode d'une classe parente,
peuvent réagir de façon différente à l'appel de cette méthode et, à cette fin, redéfinir
la méthode. Il est ensuite possible d'appeler la méthode d'un objet sans se soucier de
son type intrinsèque.