Programmation objet

(1)

Département Informatique Département Informatique

Programmation objet

Cours n°1

Rappels de première année

Conseils d'implémentation C++

Espaces de noms

Allocation dynamique

(2)

2 Département Informatique

Département Informatique

Rappels de première année Principes de la programmation objet

➢Notion d'encapsulation, protection des données

➢Données, attributs, fonctions membres

➢Exemple d'implémentation en C++

Construction et destruction d'un objet

➢Besoin d'assurer la cohérence de l'objet

➢Exemple avec prise de ressources

(3)

Allocation dynamique de mémoire

➢Différence entre allocation statique et dynamique

➢Rappels sur la notion de pointeur, valeur, référence

➢Sémantiques

➢Risques de fuites mémoire

➢Existence de "ramasse-miettes" (java, C#...)

(4)

Conseils d'implémentation en C++

Structure d'un code source C++

Plusieurs unités de compilation (fichiers .cpp) De nombreux fichiers d'en-tête (fichiers .h)

Bibliothèques statiques (.obj, .lib) et dynamiques Rôle de l'éditeur de liens

(5)

Un programme écrit en C++

=

plusieurs unités de compilation une unité contenant la fonction main

un certain nombre de bibliothèques

Un programme écrit en C++ peut utiliser le paradigme objet ou non Il peut contenir des classes, mais aussi des fonctions globales.

Par souci de lisibilité, de simplicité, de facilité de maintenance,

On choisira plutôt de multiplier de petites unités de compilation, avec une répartition logique des classes et/ou fonctions.

(6)

Conseils sur l'écriture d'une classe C++

Pour chaque classe du programme, même minime :

une seule unité de compilation, portant le nom de la classe.

La déclaration de la classe sera écrite dans un fichier d'en-tête (.h), contenant éventuellement quelques petites fonctions en ligne.

Le corps des fonctions membres de cette classe, ainsi

qu' éventuellement les fonctions globales associées se trouvera dans un fichier source .cpp .

(7)

Département Informatique Exemple : écriture d'une classe complexe

Nom de la classe : complexe

Nom de l'unité : complexe (fichiers complexe.h et complexe.cpp) Placement dans un espace de nom "iut"

Données : parties réelle et imaginaire, type double, privées

Fonctions : calcul du module, de l'argument, addition de 2 complexes

(8)

Département Informatique Fichier d'en-tête (complexe.h) :

#ifndef complexe_h

#define complexe_h // protection contre inclusions multiples namespace iut {

class complexe {

double reel, imag;

public:

complexe(double r=0, double i=0):reel(r),imag(i){}

double Module() const;

double Arg() const;

complexe& operator+=(const complexe&);

};

extern complexe operator+(const complexe&, const complexe&);

} // fin de l'espace de nommage

#endif

(9)

Département Informatique Fichier source (complexe.cpp)

#include <cmath> // pour sqrt et atan

#include "complexe.h"

namespace iut {

double complexe::Module() const {

return std::sqrt(reel*reel+imag*imag);

}

double complexe::Arg() const {

return std::atan(reel/imag);

}

(10)

complexe& complexe::operator+=(const complexe& z) {

reel += z.reel;

imag += z.imag;

return *this;

}

complexe operator+(const complexe& z1, const complexe& z2) {

complexe z(z1);

z+=z2;

return z;

}

}// fin de l'espace de noms

(11)

Département Informatique Conseils généraux sur écriture programme C++

Une unité de compilation par classe

Une unité pour la fonction main et elle seule

Une unité pour les éventuelles variables et fonctions globales Une unité au moins pour la gestion des erreurs

Utiliser les espaces de noms

Eviter l'utilisation abusive des directives using

Préférer le paradigme objet au paradigme procédural

Passage de paramètres par référence plutôt que par valeur Utiliser le mot-clé const si besoin

Eviter les macros (#define...)

Ne pas inclure de fichier d'en-tête inutile

Protéger les en-têtes contre les inclusions multiples Préférer la clarté à la concision

(12)

Département Informatique Espaces de noms

Concept plus général que celui d'une classe

Permet de rassembler plusieurs objets, fonctions ou variables ayant un lien logique ou fonctionnel entre elles.

Mot clé C++ : namespace.

namespace X { int i;}

La variable i n'est visible qu'à l'intérieur de l'espace X, à moins d'être qualifié par le nom de celui-ci :

i = 3; // erreur à la compilation, i inconnu X::i = 3; // ok, i étant défini dans X

(13)

Un espace de nom est ouvert.

namespace A { int i; } int k;

namespace A {int k;}

L'espace A contient les variables i et k.

Ici, l'espace global contient la variable k.

Attention : k et A::k sont deux variables différentes !!

Les espaces de noms permettent une structure plus propre des programmes, évitent les conflits de noms.

L'écriture et la lecture du programme sont par contre moins aisés.

(14)

Département Informatique La directive using

On peut rendre visible tout le contenu d'un espace de nom grâce à la directive C++ using.

namespace A {int i;}

i=3; // erreur, i non visible A::i = 3; // ok

using namespace A; // rend visible tout l'espace A i = 3; // ok, utilise A::i

Attention : l'emploi de cette directive peut conduire à des conflits.

int i;

namespace X {int i;}

i=3; // ok, le i global X::i = 5; // ok, le i dans X using namespace X;

i=10; // erreur : i global ou X::i ?

(15)

Il est fortement déconseillé d'utiliser la directive using dans un fichier d'en-tête (.h)

Malgré la simplification d'écriture qui en résulte, l'utilisation de using est risquée et doit être limitée.

On peut rendre une partie seulement d'un espace à l'aide de using :

#include <iostream>

using std::cout; // ne rend visible que cout int x;

cout<<"Et ca marche !";

cin>>x; // erreur, cin non visible std::cin>>x; // ok

(16)

Les espaces de nommage peuvent être imbriqués : namespace A

{

namespace B {

namespace C {

int i;

} int i;

Définition de 4 variables i : ::i (ou i)

A::i A::B::i A::B::C::i

(17)

Prochain cours :

LES EXCEPTIONS

A la semaine prochaine !