Dans le remplacement de fonction, la classe enfant redéfinit la fonction qui est déjà définie dans sa classe parent.
Il permet au programmeur de fournir une fonctionnalité dérivée spécifique à la classe (même si elle est définie dans la classe de base).
Maintenant, nous allons voir quelques exemples et comprendre le concept de surcharge de fonction en C++.
Exemple 1
J'ai défini deux classes dans l'exemple de code ci-dessous - une classe de base et une classe dérivée. La classe de base a une fonction membre, c'est-à-dire disp(). La Derived_Class est héritée de la Base_Class. La fonction disp() est présente dans Base_Class puis redéfinie dans Derived_Class.
Dans la fonction main(), un objet de Derived_Class, c'est-à-dire d, est créé. Ensuite, nous appelons la fonction disp() sur l'objet de classe dérivée, de sorte que la fonction dans la classe dérivée sera invoquée. La version de la classe de base est ignorée ici. Vous pouvez voir ci-dessous la sortie en tant que fonction – disp() dans la classe dérivée.
#comprendreen utilisant l'espace de noms std;
//classe de base
classe Base_Class
{
Publique:
annulerprofiter()
{
cout<< 'fonction disp() dans la classe de base.' <<fin;
}
};
//Classe dérivée
classe Derived_Class:classe_base publique
{
Publique:
annulerprofiter()
{
cout<< 'fonction disp() dans la classe dérivée' <<fin;
}
};
entierprincipale()
{
Dérivée_Classe d;
ré.profiter(); // fonction disp() sur l'objet de classe dérivée
revenir 0;
}
Exemple-2
Dans cet exemple, nous verrons comment appeler délibérément la version de classe de base de la fonction via l'objet de classe dérivée. Dans la définition de la fonction de classe dérivée, nous utilisons l'opérateur de résolution de portée [::] pour appeler la version de classe de base de la fonction.
#comprendreen utilisant l'espace de noms std;
classe Base_Class
{
Publique:
annulerprofiter()
{
cout<< 'fonction disp() dans la classe de base.' <<fin;
}
};
classe Derived_Class:classe_base publique
{
Publique:
annulerprofiter()
{
Classe_base::profiter(); //Appelle la version de la classe de base de disp()
}
};
entierprincipale()
{
Dérivée_Classe d;
ré.profiter();
revenir 0;
}
Exemple-3
Ceci est un autre exemple de substitution de fonction. Dans cet exemple, nous avons créé une classe parent – Animal et deux classes dérivées – Duck et Dog. La classe de base, c'est-à-dire la classe Animal, a une fonction membre sound().
Dans la classe dérivée/classe enfant, c'est-à-dire Dog, nous avons redéfini la même fonction, c'est-à-dire sound(), pour remplacer sa définition de classe de base. De même, dans l'autre classe dérivée, c'est-à-dire Duck, nous avons redéfini la même fonction, c'est-à-dire son().
Dans la fonction main(), nous avons créé l'objet dog de Dog et le canard de Duck. Ainsi, maintenant, lorsque nous appelons la fonction sound() pour chien et canard, la version de classe dérivée de la fonction sound() appellera. Vous pouvez voir la sortie du programme comme indiqué ci-dessous. Ainsi, à l'aide de la fonction de redéfinition, nous pouvons invoquer la fonction dérivée spécifique à la classe.
#comprendreen utilisant l'espace de noms std;
classe Animal
{
Publique:
annulersonner()
{
cout<< « Un bruit d'animal ! » <<fin;
}
};
//Classe dérivée – Classe Chien
classe Chien:public animal
{
Publique:
annulersonner()
{
cout<< 'Son de chien - aboiement.' <<fin;
}
};
//Classe dérivée – Classe canard
canard classe:public animal
{
Publique:
annulersonner()
{
cout<< 'Canard son - charlatan.' <<fin;
}
};
entierprincipale()
{
Chien chien;
canard canard;
chien.sonner(); //son() du chien
canard.sonner(); //son() de canard
revenir 0;
}
Conclusion
Dans cet article, j'ai expliqué le remplacement de fonction dans C++ . Le langage C++ prend en charge le polymorphisme d'exécution. La substitution de fonction permet d'obtenir le polymorphisme d'exécution en C++. Cet article a examiné le concept de substitution de fonction et comment obtenir un polymorphisme d'exécution à l'aide de la substitution de fonction.