Chapitre 1 + 2

Objectifs
Bases de la
Objectifs
Bases de la
Objectifs du cours d’aujourd’hui
POO POO
En C++ En C++
Conclusion Conclusion
Annexe: Annexe:
compilation
séparée Informatique II : compilation
séparée
Cours de programmation (C++) ◮ Introduire les notions d’encapsulation et d’abstraction

◮ Objets, instances et classes
Programmation Orientée Objet (POO) ◮ Classes en C++ p
◮ Variables d’instance p
Jamila Sam Haroud ◮ Méthodes d’instance p
◮ Encapsulation et Interface : public: et private:
Laboratoire d’Intelligence Artificielle
Faculté I&C ◮ L’objet this et le masquage

c EPFL 2002–2013
c EPFL 2002–2013
Jamila Sam Jamila Sam
ÉC O L E P O L Y T E C H N I Q U E
FÉ DÉR A L E D E L A U S A N N E
Informatique II – Cours 4 : Introduction POO – 1 / 54 ÉC O L E P O L Y T E C H N I Q U E
Informatique II – Cours 4 : Introduction POO – 2 / 54
Objectifs
Bases de la
Objets : 1ère introduction Objectifs
Bases de la
Programmation impérative/procédurale
POO
Encapsulation
POO
Encapsulation [rappel]
Abstraction Abstraction
Interface Interface
Synthèse Synthèse
Classes, Objets,
Instances
Vous avez appris à écrire des programmes de plus en plus Classes, Objets,
Instances
En C++ complexes. En C++

Dans les programmes que vous avez écrits jusqu’à maintenant,
Conclusion Il faut donc maintenant des outils pour organiser ces Conclusion
les notions de variables/types de données et de traitement de
Annexe:
compilation
programmes de façon plus efficace. Annexe:
compilation ces données étaient séparées :
séparée séparée
C’est l’un des objectifs principaux de la notion d’objet.
Les objets permettent de mettre en œuvre dans les programmes opèrent sur
les notions :
◮ d’encapsulation
traitements données
◮ d’abstraction
◮ d’héritage
◮ et de polymorphisme influencent

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Notions d’encapsulation Objectifs
Bases de la
Notion d’encapsulation (2)
POO POO
Encapsulation Encapsulation
Interface
Le principe d’encapsulation consiste à regrouper dans le même Interface Les objets sont définis par leurs attributs et leurs méthodes :
Synthèse
Classes, Objets,
objet informatique («concept»), données et traitements qui lui sont Synthèse
Classes, Objets,
Instances
spécifiques : Instances
En C++ En C++
Conclusion
◮ Les données inclues dans un objet seront appelées les Conclusion Objet1
Annexe: attributs de cet objet ; Annexe:
attribut1.1 Methode1.1
compilation compilation
séparée séparée
attribut1.2
◮ Les traitements/fonctions défini(e)s dans un objet seront
appelées les méthodes de cet objet.
Résumé du premier principe de l’encapsulation :

...
OBJET
= ObjetK
attributs attributK.1 MethodeK.1
+ MethodeK.2
méthodes

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Notion d’abstraction (1) Objectifs
Bases de la
Notion d’abstraction (2)
POO POO
Interface Interface
Synthèse Synthèse
Classes, Objets, Classes, Objets,
Instances Instances
En C++ Pour être véritablement intéressant, un objet doit permettre un En C++

Exemple : Rectangles
Conclusion certain degré d’abstraction. Conclusion ◮ la notion d’« objet rectangle » n’est intéressante que si l’on
Annexe:
compilation
Annexe:
compilation
peut lui associer des propriétés et/ou mécanismes généraux
séparée
Le processus d’abstraction consiste à identifier pour un ensemble séparée
☞ propriétés et mécanismes valables pour l’ensemble des
d’éléments : rectangles et non pas pour un rectangle particulier.
◮ des caractéristiques communes à tous les éléments ◮ Les notions de largeur et hauteur sont des propriétés
◮ des mécanismes communs à tous les éléments générales des rectangles (attributs),
◮ Le mécanisme permettant de calculer la surface d’un
☞ description générique de l’ensemble considéré : se focaliser rectangle (surface = largeur × hauteur) est commun à tous
sur l’essentiel, cacher les détails.
les rectangles (méthodes)

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Abstraction Objectifs
Bases de la
Abstraction et Encaspuslation
POO
Encapsulation (exemple) POO
Encapsulation
Interface Spécifique Interface Un intérêt de l’encapsulation est que cela permet d’abstraire :
Synthèse Synthèse
Instances Instances En plus du regroupement des données et des traitements relatifs
En C++ En C++ à une entité, l’encapsulation permet en effet de définir deux
Conclusion Conclusion niveaux de perception :
Annexe: Annexe:
compilation compilation ◮ Le niveau externe : partie « visible » (par les
séparée séparée
programmeurs-utilisateurs) de l’objet :
◮ prototype des méthodes et attributs accessibles hors de l’objet
☞ c’est l’interface de l’objet avec l’extérieur

hauteur: 30 hauteur: 15 hauteur:30 résultat du processus d’abstration
largeur:12 largeur: 26 largeur:30
surface:324 surface:390 surface:900
◮ Le niveau interne : (détails d’)implémentation de l’objet
◮ méthodes et attributs accessibles uniquement depuis l’intérieur
de l’objet (ou l’intérieur d’objets similaires)
hauteur: ◮ définition de l’ensemble des méthodes de l’objet
largeur:
surface= hauteur x largeur ☞ c’est le corps de l’objet

c EPFL 2002–2013
Jamila Sam
générique
c EPFL 2002–2013
Jamila Sam
Objectifs
Bases de la
Encapsulation et Interface Objectifs
Bases de la
Pourquoi abstraire/encapsuler ?
POO POO
Abstraction Il y a donc deux facettes à l’encapsulation : Abstraction
Interface Interface L’intérêt de regrouper les traitements et les données
Synthèse
Classes, Objets,
1. regroupement de tout ce qui caractérise l’objet : données Synthèse
Classes, Objets, conceptuellement reliées est de permettre une meilleure visibilité
Instances
(attributs) et traitements (méthodes) Instances
et une meilleure cohérence au programme, d’offrir une plus
En C++ En C++
Conclusion
2. isolement et dissimulation des détails d’implémentation Conclusion
grande modularité.
Annexe: Interface = ce que le programmeur-utilisateur (hors de Annexe:
compilation compilation L’intérêt de séparer les niveaux interne et externe est de donner
séparée l’objet) peut utiliser séparée
un cadre plus rigoureux à l’utilisation des objets utilisés dans un
☞ Concentration sur les attributs/méthodes concernant l’objet programme
(abstraction)
Les objets ne peuvent être utilisés qu’au travers de leur interfaces
Exemple : L’interface d’une voiture
(niveau externe)
◮ Volant, accélérateur, pédale de freins, etc. et donc les éventuelles modifications de la structure interne
◮ Tout ce qu’il faut savoir pour la conduire (mais pas la réparer ! restent invisibles à l’extérieur
ni comprendre comment ça marche) (même idée que la séparation prototype/définition d’une fonction)
◮ L’interface ne change pas, même si l’on change de moteur...
Règle : (masquage) les attributs d’un objet ne doivent pas être
...et même si on change de voiture (dans une certaine
accessibles depuis l’extérieur, mais uniquement par des
mesure) : abstraction de la notion de voiture (en tant
méthodes.

c EPFL 2002–2013
Jamila Sam
qu’« objet à conduire »)
c EPFL 2002–2013
Jamila Sam
Objectifs
Bases de la
Encapsulation / Abstraction : Objectifs
Bases de la
Classes et Types
POO
Encapsulation Résumé POO
Encapsulation
Interface Interface
Synthèse MIEUX : Synthèse
Instances Instances
En C++
ION
OBJET En C++
Conclusion
ACT attributs méthodes Conclusion En programmation Objet :
Annexe:
compilation
AB STR Annexe:
compilation
◮ le résultat du processus d’abstraction s’appelle une classe
séparée séparée
classe = catégorie d’objets
Interface ◮ une classe définit un type (au sens du langage de
(partie visible) (vide) programmation)
◮ une réalisation particulière d’une classe s’appelle une
instance
instance = objet
Détails d’
Implémentation
(partie interne/cachée)

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Classes v.s. instances Objectifs
Bases de la
Les classes en C++
POO POO
Encapsulation
En C++
Abstraction
class
Interface
Synthèse Rectangle Attributs En C++ une classe se déclare par le mot-clé class.
Méthodes
Classes, Objets,
Instances
Attributs: méthodes:
Encapsulation et
interface Exemple :
En C++ Accesseurs/Manipulateurs
largeur dessine() classe (type abstrait) Masquage et this class Rectangle {
Conclusion
hauteur surface() Résumé
...
Annexe: Exemple complet
compilation
séparée Existence conceptuelle (écriture du programme) Opérateur :: }; // ne pas oublier le ;
Conclusion
Existence concrète (exécution) Annexe:
compilation
12 26 30 séparée La déclaration d’une instance d’une classe se fait de la façon
30 15 30 similaire à la déclaration d’une variable classique :
instance1 instance2 instance3 nom_classe nom_instance ;
Exemple :
Rectangle rect1;
déclare une instance rect1 de la classe Rectangle.

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Déclaration des attributs Objectifs
Bases de la
Accès aux attributs
POO POO
En C++ En C++
class class
Attributs Attributs
Méthodes
Encapsulation et
La syntaxe de la déclaration des attributs est la même que celle Méthodes
Encapsulation et
interface
Accesseurs/Manipulateurs
des champs d’une structure. interface
L’accès aux valeurs des attributs d’une instance de nom
Masquage et this
Résumé
Masquage et this
Résumé
nom_instance se fait comme pour accéder aux champs d’une
Exemple complet
type nom_attribut ; Exemple complet structure :
Opérateur :: Opérateur ::
nom_instance.nom_attribut
Annexe: Annexe:
séparée
Exemple : les attributs hauteur et largeur, de type double, séparée
de la classe Rectangle pourront être déclarés par : Exemple : la valeur de l’attribut hauteur d’une instance rect1
de la classe Rectangle sera référencée par l’expression :
class Rectangle { rect1.hauteur
double hauteur;
double largeur;
};

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Déclaration des méthodes Objectifs
Bases de la
Déclaration des méthodes (2)
POO POO
En C++ La syntaxe de la définition des méthodes d’une classe est la En C++ A noter que ce n’est pas parce qu’on n’a pas besoin de passer les
class
Attributs syntaxe normale de définition des fonctions :
class
Attributs
valeurs des attributs de la classe comme arguments aux
Méthodes Méthodes méthodes de cette classe, que les méthodes n’ont jamais
Encapsulation et Encapsulation et
interface
type_retour nom_methode (type_arg1 nom_arg1, ...) { interface
d’arguments.
Masquage et this
// corps de la méthode Masquage et this
Résumé ... Résumé
Les méthodes peuvent très bien avoir des arguments : ceux qui
Exemple complet Exemple complet
Opérateur :: } Opérateur ::
sont nécessaires (et donc extérieurs à l’instance) pour exécuter
la méthode en question !
Annexe: sauf qu’on a pas besoin de passer les attributs de la classe Annexe:
compilation compilation Exemple :
séparée comme arguments aux méthodes de cette classe séparée
(on y revient dans une minute)

class Couleur { ... };
Exemple : une méthode surface() de la classe Rectangle class FigureColoree
pourrait être définie par : {
//...
class Rectangle { void colorie(Couleur c) { ... }
};
...
double surface() { FigureColoree une_figure;
return (hauteur * largeur); Couleur rouge;
//...
} une_figure.colorie(rouge);

c EPFL 2002–2013
c EPFL 2002–2013
Jamila Sam }; Jamila Sam //...
Objectifs
Bases de la
Actions et Prédicats Objectifs
Bases de la
Accès aux méthodes
POO POO
En C++ En C++ on peut distinguer les méthodes qui modifient l’état de En C++
class
l’objet (« actions ») de celles qui ne changent rien à l’objet class L’appel aux méthodes définies pour une instance de nom
Attributs Attributs
Méthodes (« prédicats »). Méthodes nom_instance se fait à l’aide d’expressions de la forme :
interface interface
Accesseurs/Manipulateurs On peut pour cela ajouter le mot const après la liste des Accesseurs/Manipulateurs nom_instance.nom_methode(val_arg1,...)
Masquage et this Masquage et this
Résumé arguments de la méthode : Résumé
Exemple complet Exemple complet
Opérateur :: type_retour nom_methode (type_arg1 nom_arg1, ...) const Opérateur ::
Exemple : la méthode
Annexe:
compilation
Exemple : Annexe:
compilation
void surface() const;
séparée séparée
class Rectangle { définie pour la classe Rectangle peut être appelée pour une
... instance rect1 de cette classe par :
double surface() const {
return (hauteur * largeur); rect1.surface()
}
...
}; Autre exemple :
Si jamais vous déclarez comme prédicat (const) une action, vous une_figure.colorie(rouge);

c EPFL 2002–2013
aurez à la compilation le message d’erreur :
c EPFL 2002–2013
assignment of data-member ‘...’ in read-only structure
Objectifs
Bases de la
Portée des attributs Objectifs
Bases de la
Accès aux attributs et méthodes
POO POO
En C++ En C++
class Remarque : Les attributs d’une classe constituent des variables class
Attributs
Méthodes
directement accessibles dans toutes les méthodes de la classes Attributs
Méthodes
Encapsulation et (i.e. des variables globales à la classe). Il n’est donc pas Encapsulation et Chaque instance a ses propres attributs : aucun risque de
interface interface
Accesseurs/Manipulateurs nécessaire de les passer comme arguments des méthodes. Accesseurs/Manipulateurs confusion d’une instance à une autre.
Résumé Résumé
Exemple complet Exemple complet classe instances accès
Opérateur :: Par exemple, dans toutes les méthodes de la classe Rectangle, Opérateur ::
Conclusion l’identificateur hauteur (resp. largeur) fait donc a priori Conclusion

rect1
Annexe: référence à la valeur de l’attribut hauteur (resp. largeur) de la Annexe: largeur=4 rect1.largeur
séparée classe. séparée hauteur=2 rect1.hauteur
Rectangle surface()
Exemple : définition d’une méthode surface pour la classe double largeur;
Rectangle double hauteur; rect2
class Rectangle { double surface() { largeur=2
rect2.largeur
double surface() const { ... hauteur=3
rect2.hauteur
return (hauteur * largeur); } surface()
rect2.surface()
}
...

c EPFL 2002–2013
};
c EPFL 2002–2013
Objectifs
Bases de la
Encapsulation et interface Objectifs
Bases de la
Encapsulation et interface (2)
POO POO
En C++ Tout ce qu’il n’est pas nécessaire de connaître à l’extérieur d’un En C++
class
Attributs objet devrait être dans le corps de l’objet et identifié par le mot clé
class
Attributs
À l’inverse, l’interface, qui est accessible de l’extérieur, se déclare
Méthodes
Encapsulation et
private : Méthodes
Encapsulation et
avec le mot-clé public:
interface interface
Accesseurs/Manipulateurs Accesseurs/Manipulateurs
Masquage et this class Rectangle { Masquage et this class Rectangle {
Résumé Résumé
Exemple complet double surface() const { ... } Exemple complet
public: // accessible partout
Opérateur ::
private: // ICI Opérateur :: double surface() const { ... }
Conclusion
double hauteur; Conclusion private:
Annexe: Annexe: ...
compilation double largeur; compilation
séparée
} séparée };
Dans la plupart des cas :

Attribut d’instance privée = inaccessible depuis l’extérieur de la
classe. C’est également valable pour les méthodes. ◮ Privé :
◮ Tous les attributs
Erreur de compilation si référence à un(e) attribut/méthode ◮ La plupart des méthodes
d’instance privée :
◮ Publique :
Rectangle.cc:16: ‘double Rectangle::hauteur’ is private ◮ Quelques méthodes bien choisies (interface)

c EPFL 2002–2013
c EPFL 2002–2013
Note : Si aucun droit d’accès n’est précisé, c’est private par défaut.
Objectifs
Bases de la
Méthodes «get» et «set» Objectifs
Bases de la
Masquage (shadowing)
POO
(« accesseurs » et « manipulateurs ») POO
En C++ En C++
class class
Attributs Attributs
Méthodes
◮ Tous les attributs sont privés ? Méthodes
interface ◮ Et si on a besoin de les utiliser depuis l’extérieur de la classe ?! interface
Masquage et this
Résumé
◮ Si le programmeur le juge utile, il inclut les méthodes Masquage et this
Résumé masquage = un identificateur « cache » un autre identificateur
Exemple complet publiques nécessaires ... Exemple complet
Opérateur ::
1. Manipulateurs (« méthodes set ») :

Opérateur ::
Situation typique : (le nom d’)un paramètre cache un (nom
◮ Modification
d’)attribut
Annexe: Annexe:
séparée
◮ Affectation de l’argument à une variable d’instance précise séparée
void setHauteur(double hauteur) {
void setHauteur(double h) { hauteur = h;} hauteur = hauteur; // Hmm.... pas terrible !
}
void setLargeur(double L) { largeur = L;}
2. Accesseurs (« méthodes get ») :
◮ Consultation
◮ Retour de la valeur d’une variable d’instance précise
double getHauteur() const { return hauteur;}

c EPFL 2002–2013
c EPFL 2002–2013
Jamila Sam double getLargeur() const { return largeur;} Jamila Sam
Objectifs
Bases de la
Masquage (2) Objectifs
Bases de la
Portée des attributs (résumé)
POO POO
En C++ En C++
class Si, dans une méthode, un attribut est masqué alors la valeur de class
Attributs
l’attribut peut quand même être référencée à l’aide du mot réservé Attributs La portée des attributs dans la définition des méthodes peut être
Méthodes Méthodes
Encapsulation et this. Encapsulation et résumée dans le schéma suivant :
interface interface
Masquage et this this est un pointeur sur l’instance courante Masquage et this
Résumé Résumé
Exemple complet
this ≃ « mon adresse »
Exemple complet class MaClasse {
int x;
Annexe: Syntaxe pour spécifier un attribut en cas d’ambiguïté : Annexe:
int y;
compilation
séparée
compilation
séparée
void une_methode ( int x )
this->nom_attribut
{ ...
Exemple :
... y ...
void setHauteur(double hauteur) { ... x ...
this->hauteur = hauteur; // fonctionne ! . . . this->x . . .
} } ...
L’utilisation de this est obligatoire dans les situations de };

masquage

c EPFL 2002–2013
Jamila Sam
(mais évitez ces situations !)
c EPFL 2002–2013
Jamila Sam
Objectifs
Bases de la
Classes = super struct Objectifs
Bases de la
Un exemple complet de classe
POO POO
En C++ En C++
class class
Attributs Attributs
Méthodes Méthodes #include <iostream>
interface interface using namespace std;
Résumé Résumé
// definition de la classe
Exemple complet
Pour résumer à ce stade, une classe c’est une struct Exemple complet class Rectangle {
public:
Conclusion ◮ qui contient aussi des fonctions (« méthodes ») Conclusion // definition des methodes
Annexe: Annexe: double surface() const { return (hauteur * largeur); }
compilation ◮ dont certains champs (internes) peuvent être cachés compilation
séparée séparée double getHauteur() const { return hauteur; }
(private:) double getLargeur() const { return largeur; }
◮ et dont d’autres constituent l’interface (public:) void setHauteur(double hauteur) { this->hauteur = hauteur; }
void setLargeur(double largeur) { this->largeur = largeur; }
private:
// declaration des attributs
double hauteur;
double largeur;
};

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Un exemple complet de classe (2) Objectifs
Bases de la
Opérateur ::
POO POO
En C++ En C++
class class
Attributs Attributs Il est possible d’écrire les définitions des méthodes à l’extérieur de
Méthodes
Encapsulation et
Méthodes
Encapsulation et
la déclaration de la classe
interface interface
//utilisation de la classe
Masquage et this
Masquage et this
☞ meilleure lisibilité du code, modularisation
Résumé Résumé
Exemple complet
int main() { Exemple complet
Opérateur :: Rectangle rect; Opérateur :: Pour relier la définition d’une méthode à la classe pour laquelle
Conclusion double lu; Conclusion elle est définie, il suffit d’utiliser l’opérateur :: de résolution de
cout << "Quelle hauteur? "; cin >> lu;
Annexe:
compilation rect.setHauteur(lu);
Annexe:
compilation
portée :
séparée séparée
cout << "Quelle largeur? "; cin >> lu;
rect.setLargeur(lu);
◮ La déclaration de la classe contient les prototypes des
cout << "surface = " << rect.surface() << endl; méthodes
◮ les définitions correspondantes spécifiées à l’extérieur de la
return 0;
} déclaration de la classe se font sous la forme :
typeRetour NomClasse::nomFonction(arg1, arg2, ...)

{...}

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Opérateur :: (2) Objectifs
Bases de la
Opérateur :: (3)
POO POO
En C++ En C++
class class
Attributs Par exemple, la déclaration de la classe Rectangle pourrait être Attributs Accompagné des définitions « externes » des méthodes
Méthodes Méthodes
Encapsulation et (dans rectangle.h) : Encapsulation et (dans rectangle.cc) :
interface interface
Accesseurs/Manipulateurs class Rectangle Accesseurs/Manipulateurs double Rectangle::surface() const
Résumé
{ Résumé
{
Exemple complet public: Exemple complet return hauteur_ * largeur_;
Opérateur ::
// prototypes des methodes Opérateur :: }
Conclusion double surface() const; Conclusion
Annexe: Annexe: double Rectangle::hauteur() const

séparée
double hauteur() const; séparée
{
double largeur() const; return hauteur_;
}
void hauteur(double);
void largeur(double); ... // idem pour largeur
// declaration des attributs void Rectangle::hauteur(double h)

private: {
double hauteur_; hauteur_ = h;
double largeur_; }
}; ... // idem pour largeur

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Objets et Classes en C++ Objectifs
Bases de la
Approche modulaire
POO POO
En C++ En C++
class MaClasse { ... }; déclare une classe.
Annexe:
MaClasse obj1; déclare une instance (objet) de la classe Annexe:
Jusqu’à maintenant vos programmes était écrit en une seule fois,
compilation
séparée
MaClasse compilation
séparée
dans un seul fichier.
Les attributs d’une classe se déclarent comme des champs d’une
Cette approche n’est pas réaliste pour des programmes plus
structure : class MaClasse { ... type attribut; ... };
conséquents, qui nécessitent partage de composants,
Les méthodes d’une classe se déclarent comme des fonctions, maintenance séparée, réutilisation, ...
mais dans la classe elle-même :
class MaClasse { ... type methode(type1 arg1, ...); ... }; On préfére une approche modulaire
Encapsulation et interface : c’est-à-dire une approche qui
class MaClasse { décompose la tâche à résoudre en sous-tâches
private: // attributs et methodes privees implémentées sous la forme de modules génériques (qui
... pourront être réutilisés dans d’autres contextes).
public: // interface : attributs et methodes publiques
...
Chaque module correspond alors à une tâche ponctuelle, à un
};
ensemble cohérent de données, à un concept de base, etc...

c EPFL 2002–2013
L’attribut particulier this est un pointeur sur l’instance courante
c EPFL 2002–2013
Jamila Sam
de la classe. Exemple d’utilisation : this->monattribut Jamila Sam
Objectifs
Bases de la
Réutilisabilité Objectifs
Bases de la
Conception modulaire
POO POO
En C++ En C++
Annexe: Annexe:
compilation
séparée La conception d’un programme doit tenir compte de deux aspects
compilation
séparée
Concrètement, cela signifie que les types, structures de données
importants : et fonctions correspondant à un « concept de base » seront
regroupés dans un fichier qui leur est propre.
◮ la réutilisation des objets/fonctions existants : bibliothèques
logicielles (« libraries » en anglais); Par exemple, on définira la structure qcm et ses fonctions dans un
(les autres/passé −→ nous/présent) fichier à part de son utilisation.
◮ la réutilisabilité des objets/fonctions nouvellement créés.
(nous/présent −→ les autres/futur)
☞ séparation des déclarations des objets de leur utilisation
effective (dans un main()).
Remarque : vous pouvez vous-même créer vos propres
bibliothèques.
Concrètement, cela crée donc plusieurs fichiers séparés qu’il
(mais non abordé dans ce cours)
faudra regrouper (« lier ») pour faire un programme.

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Exemple Objectifs
Bases de la
Compilation séparée
POO POO
En C++ struct qcm { ... }; En C++
Conclusion void affiche(const qcm& question);

int poser_question(const qcm& question);
Conclusion
☞ Pouquoi faire cela ?
Annexe: ... Annexe:
int demander_nombre(int min, int max);
compilation
séparée
void affiche(const qcm& question) compilation
séparée
◮ Pour rendre réutilisable (exemple demander_nombre) :
{ int demander_nombre(int a, int b) {
}
...
}
... évite de réinventer la roue à chaque fois
int poser_question(const qcm& question)
{
◮ Pour maintenir plus facilement : pas besoin de tout
}
...
recompiler le jour où on corrige une erreur dans
demander_nombre
◮ Pour pouvoir développer des programmes
indépendemment, c’est-à-dire même si le code source n’est
pas disponible
◮ Distribuer des bibliothèques logicielles (morceaux de code)
sans en donner les codes sources (protection intellectuelle).
int main ()
{
qcm maquestion;
...
poser_question(maquestion);
☞ Mais comment alors faire un tout (un programme complet) ?
} Comment main() connait-il le reste ?

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Compilation séparée Objectifs
Bases de la
Compilation séparée
POO POO
En C++ En C++
Annexe: Annexe:
séparée séparée De ce fait, il est nécessaire (en conception modulaire) de séparer
La partie déclaration est la partie visible du module que l’on écrit, ces parties en deux fichiers :
qui va permettre son utilisation (et donc sa réutilisation). ◮ les fichiers de déclaration (fichiers « headers »), avec une
C’est elle qui est utile aux autres fichiers pour utiliser les objets extension .h).
déclarés. Ce sont ces fichiers qu’on inclut en début de programme par
la commande #include
La partie définition est l’implémentation du code correspondant et ◮ les fichiers de définitions (fichiers sources, avec une
n’est pas directement nécessaire pour l’utilisateur du module. Elle extension .cc)
peut être cachée (aux autres). Ce sont ces fichiers que l’on compile pour créer du code
exécutable.

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Compilation séparée Objectifs
Bases de la
Compilation séparée : exemple
POO POO
En C++ En C++
Conclusion Conclusion struct qcm { ... };

Annexe:
compilation
programmeur programmeur Annexe:
compilation
void affiche(const qcm& question);
int poser_question(const qcm& question);
...
séparée
utilisateur concepteur/développeur séparée
void affiche(const qcm& question)
{
...
accord }
{
...
}
appel prototype définition

z=f(x,y) double f(double,double); double f(double a,double b)
{
...
}
#include "qcm.h" struct qcm { ... };
void affiche(const qcm& question)
{ void affiche(const qcm& question);
... int poser_question(const qcm& question);
} ...
{
...
}
fichier .h fichier .cc

c EPFL 2002–2013
c EPFL 2002–2013
Jamila Sam Jamila Sam qcm.cc qcm.h
Objectifs
Bases de la
Compilation séparée (2) Objectifs
Bases de la
RAPPEL : Compilation d’un programme C++
POO POO
En C++ En C++
compilateur
Annexe: Annexe:
compilation compilation fichier source fichier exécutable
séparée séparée
La séparation des parties déclaration et définition en deux fichiers c++ hello.cc -o hello
permet une compilation séparée du programme complet :
◮ phase 1 : production de fichiers binaires (appelés fichiers
objets) correspondant à la compilation des fichiers sources hello.cc
(.cc) contenant les parties définitions (et dans lesquels on
hello
inclut (#include) les fichiers « headers » (.h) nécessaires) ; #include <iostream>
010100001010101
◮ phase 2 : production du fichier exécutable final à partir des using namespace std;
001010101001110
fichiers objets. main() { 101111001010001
cout << "Hello World!" << endl; ...
}

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Compilation séparée d’un programme C++ Objectifs
Bases de la
Compilation séparée : phase 1
POO POO
En C++ En C++
Conclusion
c++ -c hello1.cc -o hello1.o Conclusion
Annexe:  Annexe:
Pour créer un fichier objet (identifié par une extension .o), on
compilation
séparée fichier source1 fichier objet1 
 compilation
séparée
utilise une commande de compilation du type :
compilation c++ qcm.cc -c -o qcm.o
fichier source2 fichier objet2 

c++ -c hello2.cc -o hello2.o

prototypes définitions objets
string
cmath
édition de liens
c++ hello1.o hello2.o -o hello
qcm.h qcm.cc
c++
qcm.o
fichier exécutable

c EPFL 2002–2013
c EPFL 2002–2013
Objectifs
Bases de la
Compilation séparée : phase 2 Objectifs
Bases de la
Outils de construction de projets
POO POO
En C++ En C++
Le fichier exécutable est produit par une compilation qui intègre Compiler "à la main" un projet rédigé sur plusieurs fichiers est
(« lie ») les fichiers objets nécessaires : laborieux.
Annexe: Annexe:
compilation compilation Il existe de nombreux outils pour automatiser ce traitement :
séparée c++ examen.o qcm.o -lm -o examen séparée
Par exemple :
◮ les outils intégrés de développement de projets (IDE) :
Code::Blocks, KDevelop, Anjuta, NetBeans, Eclipse, ...
libm.so
◮ CMake, http://www.cmake.org/,
qcm.o ◮ SCons, http://www.scons.org/,
examen.o ◮ Jam (BJam, KJam, ...)
c++
◮ the GNU Build Tools, alias « autotools » (automake,
examen autoconf and libtool), cf
http://sourceware.org/autobook/,
http://autotoolset.sourceforge.net/tutorial.html
☞ Nous travaillerons avec SCons : Etudiez le tutoriel de la

c EPFL 2002–2013
Jamila Sam

c EPFL 2002–2013
Jamila Sam
série 4
Objectifs
Bases de la
Ce que j’ai appris aujourd’hui Objectifs
Bases de la
La suite
POO POO
En C++ En C++
◮ quels sont les principes de base de la programmation
Annexe: Annexe:
compilation orientée-objet : encapsulation, abstraction, héritage et compilation
séparée séparée
polymorphisme ; ◮ Exercices de cette semaine :
◮ que l’on peut « encapsuler » données et traitements en ◮ Premiers programmes orientés objets
utilisant des classes d’objets ; ◮ Prise en main de l’environnement graphique (SFML)
◮ Prise en main de SCons (outil de compilation séparée)
◮ qu’il faut clairement dissocier l’interface (« publique ») de la
◮ Le prochain cours :
représentation interne (« privée ») ;
◮ Suite des concepts de POO : constructeurs et destructeurs
◮ comment réaliser les éléments de base de la POO en C++ : ◮ Surcharge des opérateurs
◮ attributs et méthodes (d’instances) ;
◮ Ensuite :
◮ encapsulation et interface : public:, private:,
« méthodes get » (accesseurs) et « méthodes set » (manipula-
◮ Héritage
-teurs) ;
◮ Polymorphisme
◮ l’attribut this et le (dé)masquage.
◮ Héritage multiple
☞ je peux maintenant mieux concevoir mes programmes grâce

à la programmation orientée objet

c EPFL 2002–2013
c EPFL 2002–2013

Chapitre 1 + 2

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Chapitre 1 + 2

Загружено:

Авторское право:

Доступные форматы

Objectifs

Cours de programmation (C++) ◮ Introduire les notions d’encapsulation et d’abstraction

En C++ complexes. En C++

Résumé du premier principe de l’encapsulation :

En C++ Pour être véritablement intéressant, un objet doit permettre un En C++

☞ c’est l’interface de l’objet avec l’extérieur

déclare une instance rect1 de la classe Rectangle.

(on y revient dans une minute)

Conclusion l’identificateur hauteur (resp. largeur) fait donc a priori Conclusion

Dans la plupart des cas :

1. Manipulateurs (« méthodes set ») :

double getHauteur() const { return hauteur;}

L’utilisation de this est obligatoire dans les situations de };

typeRetour NomClasse::nomFonction(arg1, arg2, ...)

Annexe: Annexe: double Rectangle::hauteur() const

// declaration des attributs void Rectangle::hauteur(double h)

En C++ struct qcm { ... }; En C++

Conclusion void affiche(const qcm& question);

Conclusion Conclusion struct qcm { ... };

appel prototype définition

c++ -c hello2.cc -o hello2.o

☞ Nous travaillerons avec SCons : Etudiez le tutoriel de la

☞ je peux maintenant mieux concevoir mes programmes grâce

Вам также может понравиться