Classes abstraites C ++

«Une classe dans le langage de programmation C ++ est considérée comme abstraite si elle contient au moins une seule méthode virtuelle. La méthode virtuelle peut être définie par les classes qui héritent de la classe abstraite; Sinon, la sous-classe serait devenue une classe abstraite. Des classes abstraites ont été utilisées pour construire les API C ++; Cependant, l'abstraction des données, qui sera l'idée de maintenir les paramètres de configuration en dehors des données associées, peut ne pas être mélangé avec des méthodes abstraites. Une classe abstraite fonctionne comme une classe de base à partir de laquelle certaines classes peuvent dériver. Voyons les différents exemples d'une classe abstraite."

Exemple n ° 1

La classe abstraite «S» et ses membres sont construits dans l'exemple suivant:

#inclure
Utilisation de Namespace Std;
classe S
public:
Virtual int Area () = 0;
void setWidth (int a)
wid = a;

void Setheight (int b)
hght = b;

protégé:
int wid;
int hght;
;
Classe Rectangle: public S
public:
Int Area ()
return (wid * hght);

;
Triangle de classe: public s
public:
Int Area ()
return (wid * hght) / 2;

;
int main()
Rectangle rec;
Triangle tri;
Récolte.SetWidth (15);
Récolte.Setheight (50);
Tri.SetWidth (70);
Tri.Setheight (88);
couter << "The calculated area of the required rectangle: " << Rec.Area() << endl;
couter << "The calculated area of the required triangle: " << Tri.Area() << endl;

Au début du programme, nous inclurons la bibliothèque requise . Ensuite, nous avons utilisé l'espace de noms standard comme std. Maintenant, nous allons configurer la classe nommée «S». Nous déclarons publiquement une méthode virtuelle. La fonction virtuelle que nous avons utilisée ici est la zone (). Ensuite, nous utiliserons la fonction SetWidth (). La largeur de la forme peut être spécifiée en utilisant cette fonction. La valeur de la largeur est stockée dans une variable «A».

Nous allons maintenant spécifier la valeur de la hauteur de la forme, nous utilisons donc la fonction Setheight (). Nous initialisons une variable «B» pour stocker la hauteur de la forme. Nous définissons les valeurs de largeur et de hauteur comme protégés. Le type de données de largeur et de hauteur sera un entier. Dans la ligne suivante, nous hériterons d'une forme rectangulaire de classe de la classe «S». Ici, nous trouvons la zone du rectangle, de sorte que la méthode de zone () sera appliquée. Il renvoie la zone d'un rectangle en multipliant la valeur de largeur par la valeur du rectangle.

Après tout cela, nous hériterons d'une autre forme, «triangle», de la classe «S». Maintenant, nous appliquons les formules pour obtenir la zone du triangle. La fonction zone () est appelée. Cela renvoie la valeur résultante. Nous obtenons la zone d'un triangle en multipliant la largeur par la hauteur, puis en divisant la valeur par 2. De plus, nous appellerons la fonction principale (). Nous définissons les objets des deux classes, des rectangles et des triangles, respectivement.

Maintenant, nous devons définir les valeurs de la largeur et de la hauteur du rectangle et du triangle en utilisant les méthodes SetWidth () et SetRectangle () en conséquence. En fin de compte, nous avons utilisé la déclaration «cout» pour afficher la zone calculée du rectangle et du triangle.

Exemple n ° 2

Les classes qui héritent d'une classe abstraite fournissent certaines méthodes virtuelles. Nous exécuterons l'instance dans laquelle nous héritons des classes de la classe abstraite:

#inclure
Utilisation de Namespace Std;
base de classe

int n;
public:
virtuel void f () = 0;
int geta () return n;
;
classe dérivée: base publique

int m;
public:
void f () cout << "f() is being called";
;
int Main (vide)

Dérivé x;
X.F();
retour 0;

Tout d'abord, nous avons intégré le fichier d'en-tête . Parallèlement à cela, nous utiliserons l'espace de noms standard en tant que MST. Ensuite, nous définissons la classe appelée «base». Au sein de cette classe, nous initialisons une variable «n» et le type de données de cette variable sera défini comme un entier. Ici, nous appelons la fonction de cette classe et définissons ces fonctions comme public. Nous avons appelé la méthode void f () de la classe «base». Ensuite, nous utilisons également la fonction get ().

De plus, nous hériterons de la classe dérivée de la classe parentale. En conséquence, nous en tirons la classe de base. Au sein de la classe dérivée, nous déclarerons une variable «M». Maintenant, nous appelons publiquement la fonction void f (). Dans cette fonction, l'instruction «cout» aura été utilisée pour afficher la ligne à l'écran. Commençons le code dans le corps de la fonction principale (). Pour ce faire, nous devons d'abord appeler la fonction principale (). Nous appelons la fonction f () associée à la classe dérivée. Nous avons appliqué la commande «return 0» à la fin du code.

Exemple n ° 3

Les constructeurs peuvent être présents dans une classe abstraite. Nous allons créer le constructeur dans l'illustration suivante:

#inclure
Utilisation de Namespace Std;
classe B

protégé:
int u;
public:
virtuel void f () = 0;
Base (int m)
u = m;
couter<<"Calling the base constructor\n";

;
classe dérivée: public b

à la TV;
public:
Dérivé (int m, int n): b (m) v = n;
void f () cout << "u = " << u << ", v = " << vretour 0;

Ici, nous incluons le module . Ensuite, nous incluons l'espace de noms standard en tant que MST. Nous allons construire la classe de base avec le constructeur. Ici, la classe de base agit comme une classe abstraite. Nous allons initialiser la variable «u» et le définir pour être protégé. Tout d'abord, nous avons appelé la fonction void f (). De plus, nous appellerons la fonction de base (). Cette fonction contient une variable comme argument. Nous avons utilisé la déclaration «cout» à l'intérieur de cette fonction. Nous hériterons de la classe dérivée de la classe «Base» à l'étape suivante. Au sein de la classe dérivée, nous initialiserons une variable «V».

Maintenant, nous appelons publiquement la fonction dérivée (). Nous passons deux variables comme paramètres. Nous appelons la fonction b (). Alors le vide f () est appelé. Dans cette fonction, l'instruction «cout» aura été appliquée pour afficher les valeurs. Nous devons invoquer la fonction principale (). Ici, nous construisons l'objet de classe dérivé. Cette fonction contient deux valeurs comme son attribut. Nous appelons la fonction f () associée à la classe dérivée. Nous allons entrer la commande «return 0» pour résilier le programme.

Conclusion

Nous avons parcouru la classe abstraite en C ++ dans ce tutoriel. Les éléments de classe abstraits sont difficiles à créer. Dans C ++, une méthode abstraite est une méthode virtuelle qui pourrait avoir une définition. Cependant, la classe dérivée remplacerait la méthode abstraite pour empêcher la classe dérivée de devenir également une classe abstraite. L'allocation de 0 pendant la déclaration crée une méthode virtuelle.