LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

lundi 25 septembre 2017

6 visiteurs en ce moment

Le monde des objets (3)

Une sombre histoire d’héritage…

. Par : Thierry

Attention : ce chapitre est long, ardu et demande de la concentration.
Ha ? Vous êtes encore là ? Alors lisez lentement, n’hésitez pas à revenir sur vos pas. Chaque mot est important, en particulier dans les lignes de code. Laissez les principes entrer et faire leur chemin, quitte à en rester là pour le moment et revenir plus tard reprendre la lecture…

Nous avons parlé des classes et de leur capacité à rendre un code souple simple à créer et à maintenir. Voyons maintenant les avantages du paradigme objet qui l’ont rendu incontournable.

L’héritage sans soucis

Depuis le deuxième article, nous avons vu une jolie classe Led. Mais comment ferions nous pour coder une classe LedBicouleur qui s’occuperait d’une diode à deux couleurs dotée de trois pins ? Ce type de diode est le plus souvent un assemblage de deux leds simples dans un seul boitier que l’on peut activer seules ou ensembles. Seule la cathode est partagée.

La première idée, c’est du simple copié/collé avec une petite adaptation.

  1. #define HIGH2 2 // Pour allumer la pin2
  2. #define HIGH12 3 // Pour allumer les deux pins !
  3.  
  4. class LedBicouleur
  5. {
  6. private:
  7. byte pin1;
  8. byte pin2;
  9. byte etat; // HIGH, LOW, HIGH2 et même HIGH12 !
  10. bool montageInverse;
  11. void Rafraichir();
  12.  
  13. public:
  14. LedBicouleur (byte aPin1, byte apin2, aMontageInverse = false);
  15. void Setup();
  16. void Allumer();
  17. void Allumer2();
  18. void Allumer12();
  19. void Eteindre();
  20. };

Qu’est ce qui a changé ici ? Une seconde broche pin2 a été ajoutée. La variable etat peut prendre quatre valeurs. HIGH, LOW, et deux inventions locales, HIGH2 pour allumer la pin 2, HIGH12 pour tout allumer ! Le constructeur reflète cette nouvelle organisation en ajoutant la seconde broche. Enfin, les méthodes Allumer2() et Allumer12() ont été ajoutées. Allumer() allume la première diode, Allumer2() la seconde, Allumer12() allume les deux, et Eteindre() éteint le tout.

On sent bien que c’est quand même très proche de la classe Led vue dans l’article précédent… Nous allons exploiter une nouvelle et très importante notion du C++ : l’héritage (on parle aussi de dérivation). Ce principe permet de dire qu’un objet est une sorte de un autre objet… Ici, la led bi-couleur est bien une sorte de led. On parle également de dérivation LedBicouleur serait la classe dérivée de Led. Voici comment exprimer l’héritage en code C++ :

  1. class Led // l'originale, la classe de base
  2. {
  3. ...
  4. };
  5.  
  6. class LedBicouleur : public Led // LedBicouleur dérive de Led
  7. {
  8. ...
  9. };

LedBicouleur hérite ou dérive de Led. Le mot clé public devant le nom de la classe de base, celle dont dérive LedBicouleur, est là pour lui permettre de voir le contenu de sa classe de base Led, en tout cas la partie que Led a jugé bon de ne pas déclarer privé.

Ce qui est fait, est fait !

Mais pourquoi faire une classe dérivée ? Est ce que la classe LedBicouleur ne pouvait pas exister sans dérivation ? Si, bien sûr, mais l’héritage permet de donner des comportements communs à un ensemble de classes, de capitaliser sur ce qui est déjà fait et fiabilisé, de diminuer le volume de code tout en rationalisant le fonctionnement et la maintenance.

  1. class LedBicouleur : public Led
  2. {
  3. private
  4. byte pin2;
  5.  
  6. public:
  7. LedBicouleur(byte aPin1, byte aPin2, bool aMontageInverse = false);
  8. void Allumer2();
  9. void Allumer12();
  10. };

Cette led particulière ayant deux pins différentes à piloter, il faut en ajouter une à celle déjà présente dans la classe de base, c’est pin2, et l’initialiser dans le constructeur :

  1. void LedBicouleur::LedBicouleur(byte aPin1, byte aPin2, bool aMontageInverse) : Led(aPin1, aMontageInverse)
  2. {
  3. pin2 = aPin2;
  4. pinMode(pin2, OUTPUT);
  5.  
  6. Eteindre();
  7. }

Le C++ permet de faire appel au constructeur de sa classe de base Led en lui redonnant les bons arguments, et se contente de ne faire que la partie supplémentaire autour de pin2.

Pourtant ce constructeur ne va pas fonctionner correctement. Voyez vous ce qui ne va pas ? Eteindre() n’est présent que dans Led, et pas dans LedBicouleur, ce qui fait que cette méthode ne connait pas pin2 et donc n’éteindra pas cette broche… Nous devons faire en sorte qu’Eteindre() marche pour les deux classes.

Dans le code de la méthode Led::Eteindre(), on a :

  1. void Led::Eteindre()
  2. [
  3. etat = LOW;
  4. Rafraichir();
  5. }

Dans la nouvelle classe, on a dit dès le départ que etat = LOW éteindrait les deux broches. C’est donc Rafraichir() qui doit faire ce travail. Mais cette méthode existe déjà dans Led, comment en faire une nouvelle dans LedBicouleur qui mette à jour les deux broches ? Pour cela, il y a la

surcharge

de méthode.

  1. class Led
  2. {
  3. private:
  4. byte pin;
  5. byte etat;
  6. bool montageInverse;
  7. virtual void Rafraichir();
  8.  
  9. public:
  10. Led(byte aPin, bool aMontageInverse = false);
  11. void Allumer();
  12. void Eteindre();
  13. };
  14.  
  15. class LedBicouleur : public Led
  16. {
  17. private:
  18. byte pin2;
  19. void Rafraichir();
  20.  
  21. public:
  22. LedBicouleur(byte aPin1, byte aPin2, bool aMontageInverse = false);
  23. void Allumer2();
  24. };

Dans la classe Led, est apparu le mot clé virtual qui déclare la fonction Rafraichir() virtuelle. Ce terme désigne une fonction qui dépend du type réel de la classe qui l’applique. Si c’est une Led, on utilisera Led::Rafraichir(), si c’est une LebBicouleur on utilisera LedBicouleur::Rafraichir() si elle existe, sinon on retrouvera la méthode de sa classe de base : Led::Rafraichir(). En effet, virtual ouvre une porte et permet aux classes dérivées de fournir un comportement alternatif, mais ce n’est pas une obligation ! Dans LedBicouleur, j’ai effectivement redéfini, surchargé Rafraichir(). Attention, le nom, le type de retour et les arguments doivent être exactement les mêmes, sinon le compilateur considérera qu’il s’agit d’une autre méthode, mais sans prévenir. Codons la nouvelle fonction :

  1. void LedBicouleur::Rafraichir()
  2. {
  3. byte etatLed1 = LOW;
  4. byte etatLed2 = LOW;
  5.  
  6. switch(etat)
  7. {
  8. case HIGH:
  9. etatLed1 = HIGH;
  10. break;
  11.  
  12. case HIGH2:
  13. etatLed2 = HIGH;
  14. break;
  15.  
  16. case HIGH12:
  17. etatLed1 = HIGH;
  18. etatLed2 = HIGH;
  19. break;
  20. }
  21.  
  22. if (montageInverse == true) // si c'est un montage inversé
  23. {
  24. etatLed1 = ! etatLed1; // on inverse
  25. etatLed2 = ! etatLed2; // on inverse
  26. }
  27.  
  28. digitalWrite(pin, etatLed1);
  29. digitalWrite(pin2, etatLed2);
  30. }

Dans cette fonction, on crée deux états etatLed1 et etatLed2, un pour chaque couleur de la led. Les deux sont initialisés à LOW. Puis avec le switch, chaque état est mis à HIGH en fonction de ce qui est demandé. On inverse si nécessaire en fonction du flag montageInverse, et on fini par appliquer l’état sur chaque led. Cette fonction remaniée va nous permettre de coder Allumer2() et Allumer12() assez facilement :

  1. void LedBicouleur::Allumer2()
  2. {
  3. etat = HIGH2;
  4. Rafraichir();
  5. }
  6.  
  7. void LedBicouleur::Allumer12()
  8. {
  9. etat = HIGH12;
  10. Rafraichir();
  11. }

Et là, nouveau problème. Les données pin et etat de la classe Led sont privées (private). LedBicouleur n’a pas le droit de les lire et encore moins de les changer ! Pour que ce code puisse fonctionner, elles peuvent rester cachées au yeux de tous, mais doivent devenir visibles pour les classes dérivées. C’est le rôle du modificateur protected (protégé) qui remplace private et ne laisse les données et les fonctions visibles que pour les classes dérivées.

  1. class Led
  2. {
  3. protected:
  4. byte pin;
  5. byte etat;
  6. bool montageInverse;
  7. virtual void Rafraichir();
  8.  
  9. public:
  10. Led(byte aPin, bool aMontageInverse);
  11. void Allumer();
  12. void Eteindre();
  13. };

Utiliser cette nouvelle classe est à peine plus compliqué qu’une led simple :

  1. LedBicouleur maLed(10, 11);
  2.  
  3. void setup()
  4. {
  5. maLed.Setup();
  6. }
  7.  
  8. void loop()
  9. {
  10. maLed.Allumer();
  11. delay(1000);
  12. maled.Eteindre();
  13. maLed.Allumer2();
  14. delay(1000);
  15. maLed.Eteindre();
  16. delay(1000);
  17. }

Les plus perspicaces d’entre vous auront remarqué que, pour l’instant, rien ne justifie l’emploi de l’héritage par rapport à un objet LedBicouleur qui contiendrait brutalement deux Led ! C’est d’ailleurs un excellent exercice que je vous enjoins de coder pour le plaisir…

Nous verrons dans le prochain article quel immenses avantages l’on peut retirer de l’héritage comme méthode de programmation, plutôt que la force brute…

4 Messages

Réagissez à « Le monde des objets (3) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Programmation »

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE Arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if … else

Instructions conditionnelles : le switch … case

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Arduino : toute première fois !

Démarrer en Processing (1)

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Bien utiliser l’IDE d’Arduino (1)

Bien utiliser l’IDE d’Arduino (2)

Piloter son Arduino avec son navigateur web et Node.js (1)

Piloter son Arduino avec son navigateur web et Node.js (2)

Piloter son Arduino avec son navigateur web et Node.js (3)

Les derniers articles

Piloter son Arduino avec son navigateur web et Node.js (3)


bobyAndCo

Piloter son Arduino avec son navigateur web et Node.js (2)


bobyAndCo

Démarrer en Processing (1)


DDEFF

Piloter son Arduino avec son navigateur web et Node.js (1)


bobyAndCo

Arduino : toute première fois !


Christian Bézanger

Bien utiliser l’IDE d’Arduino (2)


Thierry

Bien utiliser l’IDE d’Arduino (1)


Christian Bézanger, Dominique, Jean-Luc, Thierry

Les Timers (V)


Christian Bézanger

Trucs, astuces et choses à ne pas faire !


Dominique

Le monde des objets (4)


Thierry

Les articles les plus lus

Les interruptions (1)

Les Timers (I)

Comment gérer le temps dans un programme ?

Piloter son Arduino avec son navigateur web et Node.js (1)

Répéter des instructions : les boucles

Les Timers (III)

Bien utiliser l’IDE d’Arduino (1)

Calculer avec l’Arduino (1)

Les Timers (II)

Trucs, astuces et choses à ne pas faire !