Encapsulation des données

Définition

L’encapsulation consiste à interdire l’accès de certains membres d’une classe à toutes fonctions extérieures à la classe

il n’est plus possible d’agir directement sur les données d’un objet
la modification des membres de l’objet se fait par l'intermédiaire de méthodes associées

Syntaxe : les mots clés sont private et public

Exemple

class particule
{
private:
  // Déclaration de membres
  double m_masse;
  double m_charge;
};

Conséquence :

particule my_electron;
my_electron.m_masse = 0.511; // erreur de compilation

Exemple complet (1/2)

class particule
{
public:
  // Déclaration des méthodes d'accès
  double get_masse() const;
  double get_charge() const;

  void set_masse(const double masse_);
  void set_charge(const double charge_);

private:
  // Déclaration de membres
  double m_masse;
  double m_charge;
};

Exemple complet (2/2)

// Définition des méthodes
double particule::get_masse() const
{
  return m_masse;
}

void particule::set_masse(double masse_)
{
  m_masse = masse_;
}
...
particule my_electron;
my_electron.set_masse(0.511);
const double electron_masse = my_electron.get_masse();

Intérêts de l’encapsulation

Lors de la programmation et surtout de la réutilisation d’un objet dans un autre programme, l’encapsulation empêche la modification non voulue des données membres,
L’objet, vu de l’extérieur, n'est caractérisé que par ses méthodes :
1. l’objet est plus facile à utiliser pour quelqu’un d’extérieur : il lui suffit d’utiliser les méthodes.
2. la maintenance et l’amélioration de l’objet sont grandement facilitées. Tant que la finalité des méthodes ne change pas, on peut modifier les rouages sans perturber pour autant les utilisateurs de la classe.
3. l’objet est facilement réutilisable.

Inconvénients de l’encapsulation

De prime abord, peut paraître inutile et lourd à employer

Aparté : Méthodes constantes

 1: class particule
 2: {
 3: public:
 4:   // Déclaration des méthodes d'accès
 5:   double get_masse() const;
 6:   double get_charge() const;
 7: 
 8: private:
 9:   // Déclaration de membres
10:   double m_masse;
11:   double m_charge;
12: };

Les méthodes get_masse() et get_charge() sont déclarées comme constantes vis-à-vis des membres de la classe i.e. m_masse et m_charge

\ding{42} Ces méthodes ne peuvent pas modifier les membres de la classe

Quelques règles élémentaires

La création de chaque nouvelle classe exemple_classe se décompose en trois étapes :

création d’un fichier exemple_classe.h qui contient la déclaration de la classe,
création d’un fichier exemple_classe.cc qui contient les définitions des méthodes de la classe,
création d’un programme test test_exemple_classe.cc qui contient le programme principal i.e le bloc d’appel main.

Déclaration de la classe

Fichier `exemple_classe.h`

#ifndef __exemple_classe_h__
#define __exemple_classe_h__ 1
class exemple_classe
{
public:
  void set_dummy(const double dummy_);
  double get_dummy() const;
private:
  double m_dummy;
};
#endif

Définition de la classe

Fichier `exemple_classe.cc`

#include "exemple_classe.h"

void exemple_classe::set_dummy(const double dummy_)
{
  m_dummy = dummy_;
}

double exemple_class::get_dummy() const
{
  return m_dummy;
}

Utilisation de la classe

Fichier `text_exemple_classe.cc`

#include "exemple_classe.h"

int main()
{
  exemple_classe my_exemple_classe;
  my_exemple_classe.set_dummy(666);
  const double my_dummy = my_example_class.get_dummy();
  return 0;
}

Compilation

$ g++ exemple_class.cc test_exemple_classe.cc

-o test_exemple_classe.exe