Programmation Orientée Objet
Classes, Attributs, Méthodes,
Encapsulation, Setters & getters
Plan
Programmation Orientée Objet
Classes
Définition de méthodes internes & extèrnes
Déclaration & utilisation des objets
Accesseurs & Manipulateurs
Encapsulation
Constructeurs & Desctructeurs
2
Qu’est ce que POO?
• Programmation Orientée Objet (POO) : paradigme de
programmation informatique.
Elaborer par Alan Kay dans les années 70s.
Définition et interactions de briques logicielles
Objets
• Objet : un concept, une idée ou une entité du monde
physique
Possède une structure interne et un
comportement
Qu’est ce que POO?
Un objet est caractérisé par :
Les attributs : Données de l’objet et représente
son état
Les méthodes : Caractérise son comportement,
l’ensembles d’actions que l’objet peut réaliser.
Une identité : permet de distinguer l’objet d’une
manière unique indépendamment de son état
Qu’est ce que POO?
Une classe : La structure d’un objet
Elle définit son type
Déclaration de l’ensemble des entités qui
composeront un objet.
Un objet est une instance ou occurrence d’une
classe, on parle d’instanciation de classe
Classes
Qu’est-ce qu’une classe?
Vision ensembliste, mathématique: Une classe est un ensemble
d’objets.
Vision informatique : une classe est un type de données.
Une Classe est un ensemble et un type de données, dont les
éléments sont appelés instances (objets).
6
Classes
Syntaxe C++
La définition d'une classe débute par le mot clé « class »
class nom_classe
{
<listes des attributs>
<listes des méthodes>
};
7
Classes
Syntaxe C++
Exemple1: Exemple2:
class Voiture class Voiture
{ {
float masse; string marque;
int vittesse_max; Attributs int vitesse;
float consommation; void accelerer() {
void demmarer(); Méthodes vitesse += 10;
void fermer_porte(); }
}; };
8
Classes
Syntaxe C++
Il n’est pas possible de définir un attribut dont le type est celui de
la classe que l’on définit. Il est en revanche possible de définir un
attribut de type pointeur vers la classe en question.
class Point class Point
{ {
double x, y; double x, y;
Point *autre; Point autre; // ERREUR
}; };
9
Classes
Exemple de pointeur sur un objet de la même classe
class Noeud {
public:
int valeur;
Noeud* suivant; // Pointeur vers un autre objet de type
Noeud
};
10
Classes
Syntaxe C++
Il n'est pas possible de donner des valeurs par défaut aux
attributs lors de la définition d'une classe dans le corps de la
classe (avant C++11).
Exemple (avant C++11) :
class Point class Point
{ {
double x, y; double x, y;
int numero; int numero = 0; // ERREUR
}; };
class Noeud {
int valeur = 10; // Non autorisé avant C++11
11
};
Classes
Syntaxe C++
Il est possible de donner des valeurs par défaut aux attributs
dans la liste d'initialisation du constructeur ou directement lors
de la déclaration de l'attribut (depuis C++11).
Exemple (depuis C++11) :
class Noeud {
int valeur = 10; // Autorisé depuis C++11
Noeud() : valeur(20) {} // Valeur par défaut via constructeur
};
12
Classes
Qu’est-ce qu’un attribut d’objet?
Donnée d’un certain type qui est présenté dans chaque objet de la classe.
Synonymes : « champs », « données membres »
Le type de l’attribut est le même pour tous les objets de la même
classe.
Les valeurs sont particulières pour chaque objet.
Exemple : « les attributs d’une voiture sont sa masse, sa vitesse maximale et sa
consommation ».
13
Classes
Question 1
Définir une classe voiture, puis ajouter les attributs privés marque,
modèle et année à la classe Voiture
14
Classes
Question 1
Définir une classe voiture, puis ajouter les attributs privés marque, modèle
et année à la classe Voiture
class Voiture {
private:
string marque;
string modele;
int annee;
};
15
Classes
Qu’est-ce qu’une méthode d’objet?
Les méthodes d’objet (ou d’instance) sont des fonctions qu’il est
possible d’appliquer à un objet d’une classe.
Synonymes : « fonctions membres » ou simplement « méthodes ».
L’ensemble des méthodes forment la partie comportementale (ou
dynamique) d’un objet.
16
Définition des méthodes
Il ne faut pas passer les attributs comme arguments aux méthodes de
la classe.
Exemple
La méthode surface() de la classe Rectangle :
class Rectangle{
double hauteur;
double largeur;
double surface(){
return hauteur * largeur; // Accès aux attributs
}
//…
};
17
Définition des méthodes
Les méthodes peuvent avoir des paramètres :
Exemple
class Point{
// attributs
int x;
int y;
// méthodes
void initialise(int abs, int ord){ // abs et ord sont des paramètres
x = abs ;
y = ord ;
}
//…
};
18
Portée des variables
De manière générale: Les variable visible à l'intérieur du bloc
(ensembles des instructions entre { … }) où elle est définie.
class Visibilite{
int x;
void methodeA() { x : int, z : float, w : float
float z, w; ...
i = …;
}
void methodeB(float y) { x : int, y : float, z : int
int z;
do {
...
float w; x : int, y : float, z : int, w: float
z++;
} while (z < i);
x = z +w; w: non défini
} 19
};
Portée des variables
La redéfinition d’une variable masque la définition au niveau du bloc
englobant.
class Visibilite{
int x;
void methodeA() { x : int, z : float, w : float
float z, w; ...
i = …;
}
void methodeB(float y) { x : float, y : float, z : int
int z;
float x; //Masque l’attribut x;
do {
...
float w; x : float, y : float, z : int, w: float
z++;
} while (z < i);
x = z +w; 20
}
};
Définition des méthodes
Méthodes d’objets
On peut procéder de deux manières pour introduire une méthode dans une
classe :
définir la fonction au sein de la définition de la classe elle-même ;
déclarer la fonction dans la classe, et la définir ailleurs.
21
Définition des méthodes
Exemple: définir la fonction au sein de la définition de la classe elle-même ;
class Livre {
string titre;
string auteur;
int annee_publication;
void afficherDetails() { // Méthode définie dans la classe
cout << "Titre: " << titre << ", Auteur: " << auteur
<< ", Année de publication: " << annee_publication << endl;
}
};
22
Définition des méthodes
Exemple: déclarer la fonction dans la classe, et la définir ailleurs
class Livre { int main() {
string titre; Livre livre1("1984", "George
string auteur; Orwell", 1949);
int annee_publication; [Link]();
return 0;
// Déclaration seulement }
void afficherDetails();
};
// Définition de la méthode en dehors de la classe
void Livre::afficherDetails() {
cout << "Titre: " << titre << ", Auteur: " << auteur
<< ", Année de publication: " << annee_publication << endl;
} 23
Définition externe des méthodes
Il est possible d’écrire les définitions des méthodes à l’extérieur de
la déclaration de la classe.
Meilleure lisibilité du code, modularisation
Pour relier la définition d’une méthode à la classe pour laquelle elle est
définie, il suffit d’utiliser l’opérateur :: de résolution de portée :
La déclaration de la classe contient les prototypes des méthodes
Les définitions correspondantes spécifiées à l’extérieur de la
classe se font sous la forme :
TypeRetour Classe :: nomMethode(<paramètres>) {
// Corps de la méthode
}
24
Définition externe des méthodes
Un autre exemple de définition externe
class Rectangle {
public: // rendre les méthodes accessibles
double hauteur;
double largeur;
double surface(); // prototype
};
// définition de la méthode surface en dehors de la classe
double Rectangle::surface() {
return hauteur * largeur;
}
25
Question 2
Ajouter une méthode interne afficherInfo() à la classe Voiture pour
afficher les informations de la voiture.
26
Question 2
Ajouter une méthode interne afficherInfo() à la classe Voiture pour
afficher les informations de la voiture.
class Voiture {
string marque;
string modele;
int annee;
void afficherInfo() {
cout << "Marque: " << marque << ", Modèle: " <<
modele << ", Année: " << annee << endl;
}
};
27
Question 3
Déclare une méthode getInfo() dans la classe Voiture, mais définis-la à
l'extérieur de la classe.
28
Question 3 Classes
Déclare une méthode getInfo() dans la classe Voiture, mais définis-la
à l'extérieur de la classe.
class Voiture {
private:
string marque;
string modele;
int annee;
void afficherInfo() {
cout << "Marque: " << marque << ", Modèle: " << modele << ",
Année: " << annee << endl;
}
string getInfo(); //prototype
};
string Voiture::getInfo() {
return "Marque: " + marque + ", Modèle: " + modele + ",
Année: " + to_string(annee);
} 29
Organisation de fichiers
Méthodes d’objets
EN GENERAL, et dans un contexte de projets de grande envergure,
et pour mieux structurer le code et faciliter la maintenance:
On définit la classe et on déclare ses méthodes dans un fichier dont le
nom est celui de la classe et portant l’extension « .h ».
On définit les méthodes (leur corps) dans un fichier dont le nom est aussi
celui de la classe et portant l’extension « .cpp » qui inclut le fichier « .h ».
30
Organisation de fichiers
Méthode 1: Fichier [Link]
class Point
{
double x, y;
int numero;
void setNumero (int n)
{
numero = n;
}
double norm()
{
return sqrt(x*x + y*y);
}
};
31
Organisation de fichiers
Méthode 2
Point.h [Link]
class Point void Point::setNumero (int n) {
{ numero = n;
double x, y; }
int numero;
inline double Point :: norm() {
void setNumero (int n);
return sqrt (x*x + y*y);
double norm();
}
};
Lorsque la fonction est définie au sein de la classe, elle est
implicitement mise en ligne ("inline").
Ainsi, dans la méthode 1, les deux méthodes sont « inline ».
Dans la méthode 2, il faut mettre explicitement le mot-clé ‘inline’
32 .
Rappel de fonction en ligne
En C++, le mot-clé inline est utilisé pour suggérer au compilateur
d'intégrer le code d'une fonction directement à l'endroit où elle est
appelée, au lieu de faire un appel de fonction traditionnel.
Cela peut améliorer les performances en réduisant le coût d'appel de
fonction, surtout pour les petites fonctions.
Cependant, l'utilisation de inline n'est qu'une suggestion, et le
compilateur peut choisir de l'ignorer.
Exemple
inline double Point :: norm() {
return sqrt (x*x + y*y);
}
33
Rappel de fonction en ligne
Un appel de fonction est une rupture de séquence : à l'endroit où
un appel figure, la machine cesse d'exécuter séquentiellement les
instructions en cours ; les arguments de l'appel sont disposés sur la pile
d'exécution et l'exécution continue ailleurs, là où se trouve le code de la
fonction.
Une fonction en ligne est le contraire de cela : là où l'appel d'une
telle fonction apparait il n'y a pas de rupture de séquence. Au lieu de
cela, le compilateur remplace l'appel de la fonction par le corps de
celle-ci.
34
Fonction en ligne
En C++ on indique qu'une fonction doit être traitée en ligne en
faisant précéder sa déclaration par le mot inline.
inline int abs(int x)
{
return x>0?x:-x;
}
Lorsqu’une fonction est inline sa définition en général figure dans
un fichier .h et non dans un .cpp, pour qu'elles soient accessibles dans
plusieurs fichiers sources.
Cependant, on peut toujours choisir de les définir dans un fichier
.cpp,
35
Fonction en ligne
Exemple du programme
#include <iostream>
using namespace std;
// Définition de la fonction inline dans le même fichier .cpp
inline int carre(int x) {
return x * x;
}
int main() {
int nombre = 5;
int resultat = carre(nombre);
cout << "Le carré de " << nombre << " est " << resultat << endl;
return 0;
}
36
Actions et Prédicats
Actions : Méthodes qui modifient l'état de l'objet.
Prédicats : Méthodes qui n'altèrent pas l'état de l'objet.
Pour les prédicats, on ajoute le mot-clé const après la liste des
paramètres de la méthode :
• Cela garantit que la méthode ne modifiera pas les attributs de
l'objet.
• Cela permettra de faire appel à la méthode de prédicat sur un
objet constant
int obtenirValeur() const; // Méthode constante (prédicat)
---
const MaClasse objConst({10, 20, 30});
bool result = [Link](20); // Appel à la méthode de prédicat
37
Actions et Prédicats
class Rectangle {
public: // rendre les méthodes accessibles
double hauteur;
double largeur;
double surface() Const; //Utilisation de const pour le prédicat
};
double Rectangle::surface() Const{
return hauteur * largeur;
}
38
Déclaration des objets
Déclaration d’un objet (ou une instance d’une classe) se fait de façon
similaire à la déclaration d’une variable:
maClasse nomObjet;
Exemples:
Rectangle rect; //déclare une instance rect de la classe Rectangle.
Point p; //déclare une instance p de la classe Point.
39
Utilisation des objets
Pour accéder aux membres d'un objet on utilise une notation pointée
. .
( ): nomObjet nom_du_membre
Le membre pouvant être soit un attribut soit une méthode.
Exemples:
//La valeur de l’attribut hauteur d’une instance rect de la classe
//Rectangle, sera référencée par l’expression :
[Link];
//La valeur de méthodes surface() d’une instance rect de la classe
//Rectangle, sera référencée par l’expression :
[Link]()
40
Appel aux membres (attributs/méthodes)
class Rectangle {
Public:
double hauteur;
double largeur;
double surface() const{
return hauteur * largeur; }
};
int main(){
Rectangle rect; //Création de l’instance rect de la classe Rectangle
[Link] = 5.0;//Appel à l’attribut hauteur
[Link] = 6.0; //Appel à l’attribut largeur
//Appel à la méthode membre surface()
cout << " Surface du rectangle = " << [Link]() << endl;
// ...
} 41
Accès aux attributs et méthodes
Chaque instance a ses propres attributs : aucun risque de confusion
d’une instance à une autre.
[Link]() //méthode surface de la classe Rectangle s’appliquant à
//rect1
[Link]() // l’équivalent de Rectangle::surface(&rect1)
42
Accès aux attributs et méthodes
Exemples: La classe Point
class Point {
public:
double x, y;
int numero;
// Méthode pour définir le numéro du point
void setNumero(int n) {
numero = n;
}
// Méthode pour calculer la norme (distance à l'origine)
double norm() {
return sqrt(x * x + y * y);
}
// Méthode pour afficher les coordonnées du point
void show() {
cout << "Point " << numero << ": (" << x << ", " << y << ")" << endl;
}
};
43
Accès aux attributs et méthodes
Exemples(suite): différents types d’accès aux attributs et méthodes
int main() {
// Création d'un objet Point sur la pile // Accès aux attributs et méthodes
Point pa; cout << "Norme de pa: " << [Link]() ;
pa.x = 3.0; cout << "Norme de pb: " << pb->norm();
pa.y = 4.0; cout << "Norme de tp[0]: " << tp[0].norm();
[Link](1);
// Affichage des points
// Création d'un objet Point sur le tas [Link]();
Point* pb = new Point; pb- >show();
pb->x = 6.0; tp[0].show();
pb->y = 8.0;
pb->setNumero(2); // Libération de la mémoire pour pb
delete pb;
// Création d'un tableau de 3 points
Point tp[3]; return 0;
tp[0].x = 1.0; }
tp[0].y = 2.0;
tp[0].setNumero(3);
44
Question 4
Créez des objets de la classe Voiture de manière suivante :
• Instanciez trois objets Voiture sur la pile(déclaration normale).
• Instanciez un objet Voiture sur le tas(utilisation d'un pointeur).
• Créez un tableau de 3 voitures.
45
Question 4 Classes
class Voiture {
private:
string marque;
string modele;
int annee;
public:
Voiture(string m, string mo, int a) : marque(m), modele(mo), annee(a) {}
void afficherInfo() {
cout << "Marque: " << marque << ", Modèle: " << modele << ", Année: " <<
annee << endl;
}
};
46
Question 4 Classes
int main() {
// 1. Objets sur la pile
Voiture voiture1("Toyota", "Corolla", 2020);
Voiture voiture2("Honda", "Civic", 2021);
Voiture voiture3("Ford", "Focus", 2019);
// 2. Objet sur le tas (pointeur)
Voiture* p = new Voiture("Nissan", "Sentra", 2022);
// 3. Tableau de 3 voitures
Voiture tableauVoitures[3] = {
Voiture("Peugeot", "308", 2020),
Voiture("Renault", "Clio", 2021),
Voiture("Volkswagen", "Golf", 2019)
};
// Libération de la mémoire pour l'objet sur le tas
delete p;
}
47
