Série 3  (Niveau 0):
Premiers pas en POO

Exercice 0.1 : reprise de l'exemple du cours (POO, niveau 0)

Le but de cet exercice est de reprendre l'exemple du cours illustrant les notions d'objet et de classe.

Le but est de définir une classe Rectangle représentant une abstraction (informatique) de ce qu'est un rectangle : une largeur, une longueur et sa surface.

Commencez par ouvrir le fichier Rectangle.cc et définissez y la classe :

class Rectangle { };

Bien ! Prévoyons tout de suite d'utiliser notre toute première classe. Cela se fait comme n'importe quelle autre variable utilisée jusqu'à maintenant, la classe Rectangle étant simplement un nouveau type :

class Rectangle
{
};

int main()
{
  Rectangle rect;
  return 0;
}

Bon, jusque là pas grand chose de bien intéressant. Implémentons maintenant l'abstraction « rectangle » en commençant par les deux attributs largeur et longueur.

Cela se fait aussi simplement que pour des champs d'une structure.

class Rectangle
{
  double largeur;
  double longueur;
};
...

Passons maintenant à la surface, que nous implémentons sous la forme d'une méthode, c'est-à-dire une fonction propre à la classe.

Les méthodes se déclarent comme les fonctions usuelles, sauf :

• qu'on la met à l'intérieur de la classe (et non pas à l'extérieur) ;
• que l'on a pas besoin de passer comme argument les attributs de la classe. Ces attributs ont en effet toute la classe comme portée (i.e. ce sont des variable globales à la classe, donc tout élément de la classe les connaît).

Dans notre cas, on a donc pas besoin de passer largeur et longueur à la méthode surface.

class Rectangle
{
  double largeur;
  double longueur;

  double surface ()
  {
    return largeur * longueur;
  }

On peut maintenant déjà tester notre programme :

#include <iostream>   
using namespace std;  

class Rectangle
{
  double largeur;
  double longueur;

  double surface ()
  {
    return largeur * longueur;
  }
};

int main()
{
  Rectangle rect;
  rect.largeur = 1.5;
  rect.longueur = 12.8;
  cout << "Surface : " << rect.surface() << endl;
  return 0;
}

Essayez de compiler ce programme. Que se passe-t-il ?

Le message est assez clair : tout les attributs sont privés. Cela veut dire qu'on ne peut pas les utiliser hors de l'objet (ils ne font pas partie de l'interface de l'objet).

En particulier, on n'a pas le droit de faire rect.largeur ! Ce n'est pas défini.

Pour rendre accessible depuis l'extérieur un attribut, il faut le déclarer comme public: :

#include <iostream>    
using namespace std;   

class Rectangle
{
public:
  double largeur;
  double longueur;

  double surface ()
  {
    return largeur * longueur;
  }
};

int main() {
  Rectangle rect;
  rect.largeur = 1.5;
  rect.longueur = 12.8;
  cout << "Surface : " << rect.surface() << endl;
  return 0;
}

Recompilez. Ça fonctionne cette fois-ci !

Essayons maintenant d'affiner notre « style objet » en rendant privé les attributs et ne laissant public que des méthodes :

#include <iostream>    
using namespace std;

class Rectangle
{
private:
  double largeur;
  double longueur;

public:
  double surface ()
  {
    return largeur * longueur;
  }
};

int main()
{
  Rectangle rect;
  rect.largeur = 1.5;
  rect.longueur = 12.8;
  cout << "Surface : " << rect.surface() << endl;
  return 0;
}

Il est clair que comme ceci le programme ne compile plus, puisque largeur et longueur sont redevenus privés (donc rect.largeur est de nouveau interdit).

Il faut pour accéder aux attributs de la classe mettre en place les méthodes « get » et « set » correspondantes (elles sont évidement publiques !).

Cela se fait simplement, de façon similaire à ce que nous avons fait jusqu'ici :

#include <iostream>    
using namespace std;   

class Rectangle
{
private:
  double largeur;
  double longueur;

public:
  double surface ()
  {
    return largeur * longueur;
  }
  double getLongueur() { return longueur; }
  double getLargeur()  { return largeur;  }
  void setLargeur(double l)  { largeur  = l; }
  void setLongueur(double l) { longueur = l; }
};

int main()
{
  Rectangle rect;
  rect.setLargeur(1.5);
  rect.setLongueur(12.8);
  cout << "Surface : " << rect.surface() << endl;
  return 0;
}

Pour finir et être parfaitement « propre », on peut marquer explicitement les méthodes qui ne modifient pas les attributs de l'objet (on parle de méthodes « prédicat ») par l'ajout du mot const derrière la déclaration des arguments de ces méthodes :

#include <iostream>    
using namespace std;   

class Rectangle
{
private:
  double largeur;
  double longueur;

public:
  double surface () const
  {
    return largeur * longueur;
  }
  double getLongueur() const { return longueur; }
  double getLargeur()  const { return largeur;  }
  void setLargeur(double l)  { largeur  = l; }
  void setLongueur(double l) { longueur = l; }
};

int main()
{
  Rectangle rect;
  rect.setLargeur(1.5);
  rect.setLongueur(12.8);
  cout << "Surface : " << rect.surface() << endl;
  return 0;
}

Retour à la série