Abstraction en C++ avec exemples

L’abstraction est l’une des fonctionnalités de la programmation orientée objet, où vous n’affichez que les détails pertinents à l’utilisateur et masquez les détails non pertinents. Par exemple, lorsque vous envoyez un e-mail à quelqu’un, vous cliquez simplement sur envoyer et vous obtenez le message de réussite, ce qui se passe réellement lorsque vous cliquez sur envoyer, comment les données sont transmises sur le réseau au destinataire vous est cachée (parce que cela ne vous concerne pas) .

Voyons comment cela peut être réalisé dans un programme C++ en utilisant des spécificateurs d’accès :

Exemple d’abstraction

#include <iostream>
using namespace std;
class AbstractionExample{
private:
/* En rendant ces données membres privées, j'ai
* les a cachés du monde extérieur.
* Ces données membres ne sont pas accessibles en dehors
* la classe. La seule façon de définir et d'obtenir leur
* valeurs est à travers les fonctions publiques.
*/
int num;
char ch;

public:
void setMyValues(int n, char c) {
num = n; ch = c;
}
void getMyValues() {
cout<<"Numbers is: "<<num<< endl;
cout<<"Char is: "<<ch<<endl;
}
};
int main(){
AbstractionExample obj;
obj.setMyValues(100, 'X');
obj.getMyValues();
return 0;
}

Résultat:

Numbers is: 100
Char is: X

Avantage de l’abstraction des données

Le principal avantage de l’utilisation de cette fonctionnalité est que lorsque le code évolue et que vous devez faire quelques ajustements dans le code, vous n’avez qu’à modifier la classe de haut niveau où vous avez déclaré les membres comme private. Étant donné qu’aucune classe n’accède directement à ces membres de données, vous n’avez pas besoin de modifier le code de classe de bas niveau (niveau utilisateur).
Imaginez que si vous aviez rendu ces membres de données public, si à un moment donné vous vouliez changer le code, vous deviez faire les ajustements nécessaires à toutes les classes qui accèdent directement aux membres.

Les autres avantages de l’abstraction de données sont :

1. Rend l’application sécurisée en rendant les données privées et en évitant l’erreur au niveau de l’utilisateur qui peut corrompre les données.
2. Cela évite la duplication de code et augmente la ré-utilisabilité du code.

Interfaces en C++ : classe abstraite

En C++, nous utilisons indifféremment les termes classe abstraite et interface. Une classe avec une fonction virtuelle pure est appelée classe abstraite. Par exemple la fonction suivante est une pure fonction virtuelle :

virtual void fun() = 0;

Une fonction virtuelle pure est marquée par un mot-clé virtual et a = 0 après sa signature. Vous pouvez appeler cette fonction une fonction abstraite car elle n’a pas de corps. La classe dérivée doit donner l’implémentation à toutes les fonctions virtuelles pures de la classe parent sinon elle deviendra une classe abstraite par défaut.

Pourquoi avons-nous besoin d’une classe abstraite?

Comprenons cela à l’aide d’un exemple concret. Disons que nous avons une classe Animal, l’animal dort (sleeps), l’animal émet un bruit (sound), etc. Pour l’instant, je considère uniquement ces deux comportements et je crée une classe Animal avec deux fonctions sound() et sleep().

Maintenant, nous savons que les sons d’animaux sont différents, le chat dit « miaou », le chien dit « ouah ». Alors, quelle implémentation dois-je donner dans la classe Animal pour la fonction sound(), la seule et bonne façon de le faire serait de rendre cette fonction purement abstraite de sorte que je n’ai pas besoin de donner l’implémentation dans la classe Animal mais toutes les classes qui héritent de la classe Animal doivent donner une implémentation à cette fonction. De cette façon, je m’assure que tous les animaux ont un son mais qu’ils ont leur son unique.

Le même exemple peut être écrit dans un programme C++ comme celui-ci :

Exemple d’une classe abstraite

#include<iostream>
using namespace std;
class Animal{
public:
   //Pure Virtual Function
   virtual void sound() = 0;

   //Normal member Function
   void sleeping() {
      cout<<"Sleeping";
   }
};
class Dog: public Animal{
public:
   void sound() {
      cout<<"Woof"<<endl;
   }
};
int main(){
   Dog obj;
   obj.sound();
   obj.sleeping();
   return 0;
}

Règles de la classe abstraite

1. Comme nous l’avons vu, toute classe qui a une fonction virtuelle pure est une classe abstraite.
2. Nous ne pouvons pas créer l’instance de classe abstraite. Par exemple : Si j’ai écrit cette ligne Animal obj; dans le programme ci-dessus, cela aurait provoqué une erreur de compilation.
   Nous pouvons créer un pointeur et une référence de la classe abstraite de base vers l’instance de la classe enfant. Par exemple, ceci est valide :

3. Animal *obj = new dog();
   obj->sound();

   La classe abstraite peut avoir des constructeurs.
   Si la classe dérivée n’implémente pas la fonction virtuelle pure de la classe parente, alors la classe dérivée devient abstraite.