Que sont les interfaces dans C ++

Les interfaces, communément appelées classes abstraites ne sont qu'une source de décrire le comportement de la classe sans s'être engagée dans la mise en œuvre de la classe. Il n'y a pas de concept intégré d'interfaces dans la programmation C ++. Pour commencer à créer une interface, nous devons d'abord établir une classe abstraite uniquement avec des fonctions virtuelles pures.

Les interfaces en C ++ sont appliquées à l'aide de classes abstraites. D'un autre côté, une classe est appelée une classe abstraite si au moins une fonction à l'intérieur d'une classe est déclarée comme une fonction virtuelle pure.

Quelle est la fonction virtuelle pure

Le Fonction virtuelle pure signifie que les utilisateurs déclarent simplement la fonction et non sa définition. Méthode / fonction Le remplacement est utilisé pour implémenter des méthodes virtuelles pures à la classe dérivée. Une fonction est considérée comme un virtuel pur s'il est décrit à l'intérieur de la classe comme indiqué ci-dessous:

Voici la syntaxe d'un Fonction virtuelle pure de classe de classe.

Salle de classe
public:
// Fonction virtuelle pure
Virtual Double Getarea () = 0;
privé:
double longueur; // longueur d'une pièce
double largeur; // Largeur d'une pièce
;

Qu'est-ce que la classe abstraite

Une classe qui a été créée spécifiquement dans le but de servir de classe de base est nommée classe abstraite. Au moins une fonction virtuelle pure doit être présente dans la classe abstraite. Il peut inclure des variables et des fonctions standard. Les classes dérivées de la classe abstraite devraient implémenter une fonction virtuelle pure de la classe de base, sinon elles deviendront abstraites.

Considérez l'exemple suivant, dans lequel la classe parent donne une interface à une classe de base afin que la classe de base applique une fonction virtuelle pure appelée getarea (). Deux classes différentes utilisent la même chose getarea () fonction, mais la sortie des deux cas sera différente.

#inclure
Utilisation de Namespace Std;
forme de classe

public:
virtual int getarea () = 0;
void SetWidth (int wth)

largeur = wth;

void setLength (int lth)

longueur = lth;

protégé:
Largeur int;
longueur int;
;
Rectangle de classe: forme publique

public: int getarea ()

return (largeur * longueur);

;
Triangle de classe: forme publique

public: int getarea ()

return (largeur * longueur) / 2;

;
int Main (vide)

Rectangle r;
Triangle t;
R.SetWidth (9);
R.setLength (5);
couter << "Area of Rectangle: " << R.getArea() << endl;
T.SetWidth (9);
T.setLength (5);
couter << "Area of Triangle: " << T.getArea() << endl;
retour 0;

Sortir

Importance des interfaces

Toute classe dérivée d'une classe abstraite pure (interface) doit toujours implémenter chacune des méthodes de la classe de base, i.e., Interface. Les pointeurs d'interface peuvent être transmis aux fonctions ainsi qu'aux classes, ce qui nous permet d'appeler les fonctions de la classe dérivée de là-bas.

Quelles sont les règles d'utilisation des interfaces

Il existe des règles suivantes que les utilisateurs devraient suivre pour utiliser les interfaces en C ++:

• Déclarer uniquement les fonctions virtuelles pures.
• Attribué seulement 0 aux fonctions virtuelles pures.
• Ne créez pas l'interface des classes.
• En utilisant une référence à une classe abstraite de base, nous pouvons créer un pointeur vers une instance de la classe dérivée.

Dans le code suivant, une interface linuxhint, Comme une classe abstraite a été créée en utilisant une méthode virtuelle pure, ainsi que sa fonction est appliquée dans la classe enfant, et nous avons appelé le returnstring () Méthode dans la fonction principale en suivant les règles d'interface.

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
classe Linuxhint

public:
String virtuel returnString () = 0;
;
Enfant de classe: public Linuxhint

public:
String returnstring ()

retourner "Bonjour Linuxhint";

;
int main()

Child Child_Object;
LinuxHint * pnttr;
pnttr = & child_object;
couter retour 0;

Sortir

Conclusion

Les interfaces sont des classes abstraites qui décrivent le comportement de la classe nécessitant d'implémenter la classe requise en C++. Les directives susmentionnées sont cruciales pour un débutant pour améliorer leurs compétences en programmation C ++ en travaillant avec les interfaces. Vous trouverez également quelques exemples qui vous aideront à apprendre la mise en œuvre des interfaces en C++.