Introduction à la classe abstraite en C ++

Une classe est un type de données défini par l'utilisateur et possède ses propres membres et fonctions de données. Les membres et les fonctions peuvent être utilisés en créant un objet ou une instance de cette classe. La mémoire est allouée à une classe uniquement lorsqu'un objet est créé.

Lorsque nous voulons dériver certains comportements ou caractéristiques d'une classe à une autre classe, nous utilisons le concept d'héritage. Il s'agit de la méthode d'héritage de quelques propriétés de la classe parente (classe de base) à la classe enfant (classe dérivée).

Dans l'implémentation et l'héritage de classe, lorsque nous voulons définir les mêmes fonctions à la fois dans la classe de base et dérivée, nous utilisons le mot-clé «virtuel» avec la fonction de classe de base. Cette fonction «virtuelle» spécifie que la même fonction est redéfinie ou remplacée dans la classe dérivée.

Une classe abstraite est une classe avec une fonction virtuelle pure. Maintenant, qu'est-ce qu'une fonction virtuelle pure? Une fonction virtuelle pure est une fonction virtuelle qui n'a pas de corps et est affectée de 0. Ce type de fonction est implémenté lorsque nous avons besoin d'une fonction mais nous ne savons pas actuellement quelle est sa fonction. Cette fonction doit être implémentée ou définie dans la classe dérivée. Sinon, la classe dérivée devient également une classe abstraite.

Une fonction virtuelle pure est définie comme suit:

virtual void func () = 0;

Exemple de classe abstraite en C ++

Ici, nous discutons de l'exemple de classe abstraite en C ++ avec des détails:

#include
using namespace std;
class Sample_Class (
int a = 5;
public:
virtual void sample_func() = 0;
void print_func() (
cout << a;
)
);
class Derived_Class : public Sample_Class (
public:
void sample_func() (
cout << "pure virtual function is implemented";
)
);
int main() (
Derived_Class d_object;
d_object.sample_func();
)

Production:

Ici, Sample_Class est la classe de base et Derived_Class est dérivé de Sample_Class. Une fonction virtuelle pure appelée sample_func () est déclarée dans la classe de base. Il est affecté à 0, ce qui signifie qu'il n'a personne et rien n'est implémenté à l'intérieur de la fonction. Ainsi, la classe de base est devenue une classe abstraite car elle a une fonction virtuelle pure. Initialement, lorsque Derived_Class est dérivée de la classe de base, elle devient également une classe abstraite. Mais dans la classe dérivée, la classe sample_func () est définie, ce qui empêche la classe dérivée de devenir une classe abstraite. Lorsque l'objet de classe dérivé est créé et que la fonction est appelée, nous obtenons la sortie imprimée comme «la fonction virtuelle pure est implémentée».

Une classe abstraite ne peut pas être instanciée, ce qui signifie que nous ne pouvons pas créer une instance ou un objet pour une classe abstraite. L'objet ne peut pas être créé car la classe n'est pas entièrement implémentée. Il s'agit en fait d'une base pour une classe qui est implémentée complètement plus tard. Mais des pointeurs ou des références peuvent être créés pour une classe abstraite. Ce pointeur peut être utilisé pour appeler les fonctions de classe dérivées. Une classe abstraite peut avoir d'autres membres de données et fonctions similaires à l'implémentation de classe normale avec une fonction virtuelle pure.

Le point ci-dessus peut être expliqué par le programme ci-dessous

class Class1 (
int a;
public:
virtual void func1() = 0;
void func2() (
cout << "base class";
)
);
class Class2 : public Class1 (
public:
void func1() (
cout << "func1 in derived class";
)
);
int main() (
Class1 b; //---------- > this line will cause an error
//Class1 *b = new Class2(); //---------- > pointer can be created, so this line is correct
// b -> func1();
)

Production:

Ici, nous obtiendrons une erreur car un objet ne peut pas être créé pour la classe abstraite.

Au lieu de cela, les 2 e et 3 e lignes de code peuvent être implémentées, un pointeur peut être créé et peut être utilisé pour appeler la fonction de classe dérivée.

Ici, dans la fonction ci-dessus, Class1 est la classe de base et comme elle a une fonction virtuelle pure (func1), elle est devenue une classe abstraite. Class2 est dérivé de la classe parent Class1. Le func1 est défini dans la classe dérivée. Dans la fonction principale, lorsque nous essayons de créer un objet de type classe de base, nous obtiendrons une erreur, car les objets ne peuvent pas être créés pour la classe abstraite. Alors que lorsque nous essayons de créer un pointeur de type classe de base, il sera créé avec succès et nous pouvons le pointer vers la classe dérivée. Ce pointeur peut être utilisé pour appeler la fonction de classe dérivée.

Une classe abstraite peut avoir un constructeur similaire à l'implémentation de classe normale. Dans le cas du destructeur, nous pouvons déclarer un destructeur virtuel pur. Il est important d'avoir un destructeur pour supprimer la mémoire allouée à la classe. Le destructeur virtuel pur est un destructeur affecté à 0 mais il doit être défini par la même classe, car le destructeur n'est généralement pas remplacé.

Exemple d'implémentation de constructeur et destructeur pour la classe abstraite en C ++

Ici, nous discutons de l'exemple de classe abstraite en C ++ avec des détails:

class Base (
public:
int a;
virtual void func1() = 0;
// Constructor
Base(int i) (
a = i;
)
// Pure Virtual destructor
virtual ~Base() = 0;
);
// Pure virtual destructor is defined
Base :: ~Base() (
cout << "Pure virtual destructor is defined here" << endl;
)
class Derived : public Base (
int b;
public:
// Constructor of derived class
Derived(int x, int y) : Base(y) ( b = x; )
// Destructor of derived class
~Derived() (
cout << "Derived class destructor" << endl;
)
//Definition for pure virtual function
void func1() (
cout << "The value of a is " << a << " and b is " << b << endl;
)
);
int main() (
Base *b = new Derived(5, 10);
b->func1();
delete b;
)

Sortie :

Ici, dans l'exemple ci-dessus, la classe de base est une classe abstraite avec une fonction virtuelle pure func1 (), un constructeur et un destructeur virtuel pur. La fonction virtuelle pure est définie dans la classe dérivée, empêchant ainsi la classe dérivée de devenir une classe abstraite. Le destructeur virtuel pur est défini par la classe Base en dehors de la classe. Si nous voulons définir la fonction membre d'une classe en dehors de la classe, l'opérateur de résolution de portée doit être utilisé comme indiqué dans l'exemple. Un pointeur de type classe de base est créé et pointe vers la classe dérivée. Lorsque le destructeur est appelé à l'aide de «supprimer», le destructeur de classe dérivé est d'abord appelé, puis le destructeur de classe de base est appelé.

Conclusion

Par conséquent, pour tout compiler sur une classe abstraite, nous pouvons dire que la classe abstraite est une classe avec une fonction virtuelle pure. Cette fonction virtuelle pure doit être définie dans la classe dérivée, sinon la classe dérivée devient également une classe abstraite. L'objet ne peut pas être créé pour la classe abstraite, mais un pointeur peut être créé qui peut être pointé vers la classe dérivée.

Articles recommandés

Ceci est un guide de la classe abstraite en C ++. Nous discutons ici de l'introduction à la classe abstraite ainsi que de l'implémentation du constructeur et du destructeur en C ++ avec son exemple. Vous pouvez également consulter les articles suivants pour en savoir plus-

  1. Classe abstraite en Python
  2. Classe abstraite en Java
  3. Constructeur et destructeur en C ++
  4. Remplacement en C ++
  5. Surcharge en Java
  6. Les 11 principales fonctionnalités et avantages de C ++