Champs privés et publiques

Dans une classe, les champs et les fonctions membres peuvent être protégés. Ils sont dans ce cas accessibles seulement par les fonctions membres de cette classe, et on ne peut pas les appeler ailleurs.

L'intérêt est d'obliger le programmeur à passer par certaines fonctions pré-définies afin qu'il ne puisse pas manipuler à sa guise les champs d'un objet. Imaginons par exemple dans l'exemple précédent qu'un programmeur fasse:

Tableau A;
A.n = 5;
A.tab = new double[4];

Dans ce cas, le champ n ne correspond plus à la taille du tableau, ce qui est embêtant puisque toute la classe était construite dans cette optique. Si le programmeur ajoute maintenant:

A.zero();

il y aura une erreur à cause d'une tentative d'accès à la cinquième case A.tab[4] pour lui affecter 0. alors que le tableau n'a que 4 cases !

L'idéal serait alors d'avoir une classe de la forme (avec la même définition de alloue que prédédemment):

struct Tableau {

  double* tab;
  int n;

  void alloue(int a);
  int consulte_n();
  double consulte_element(int i);
  void modifie_element(int i, double x);

};



int Tableau::consulte_n(){
  return n;
}

double Tableau::consulte_element(int i){
  return tab[i];
}

void Tableau::modifie_element(int i, double x){
  tab[i] = x;
}

où le programmeur en dehors de la classe aurait accès aux quatre fonctions (pour respectivement allouer le tableau avec la taille correspondante, consulter la valeur de n sans pouvoir la modifier, consulter et modifier la valeur d'un élément du tableau sans avoir accès directement au champ tab afin de ne pas pouvoir changer le réallouer n'importe comment sans changer n en conséquence), mais sans pouvoir accéder directement aux champs tab et n afin de préserver la cohérence de l'objet.

Pour ce faire, il suffit d'ajouter public: devant les champs que l'on peut consulter en dehors de la classe, et private: devant ceux que l'on veut réserver à l'usage interne de la classe. L'exemple précédent devient alors :

struct Tableau {

 private:

  double* tab;
  int n;


 public: 

  void alloue(int a);
  int consulte_n();
  double consulte_element(int i);
  void modifie_element(int i, double x);

};

Dans une classe définie avec le mot-clé struct, les champs sont par défaut public si aucun mot-clé de protection n'a été précisé avant. Il existe un autre mot-clé pour définir les classes, il s'agit de... class. La seule différence entre struct et class est que, par défaut, si aucun mot-clé de protection n'a été précisé avant, les champs d'une class sont private. Ainsi l'exemple précédent se ré-écrit:

class Tableau {

  double* tab;
  int n;

 public: 

  void alloue(int a);
  int consulte_n();
  double consulte_element(int i);
  void modifie_element(int i, double x);

};

Nous utiliserons désormais class au lieu de struct.