De plus, nous étudions la différence entre surcharge et dépassement à l’aide d’un tableau de comparaison.
Tableau de comparaison:
| Base de comparaison | Surcharge | Primordial |
|---|---|---|
| Prototype | Le prototype diffère selon le nombre ou le type de paramètre. | Tous les aspects du prototype doivent être identiques. |
| Mot-clé | Aucun mot-clé appliqué lors d'une surcharge. | La fonction à remplacer est précédée du mot-clé 'virtual' dans la classe de base. |
| Facteur distinctif | Le nombre ou le type de paramètre diffère, ce qui détermine la version de la fonction appelée. | La fonction de la classe qui est appelée par le pointeur est déterminée par l'adresse de l'objet de la classe affecté à ce pointeur. |
| Définition du motif | Les fonctions sont redéfinies avec le même nom, mais un nombre et un type de paramètre différents. | La fonction est définie, précédée du mot clé 'virtual' dans la classe principale et redéfinie par la classe dérivée avec le mot clé out. |
| Temps d'accomplissement | Temps de compilation. | Temps d'exécution. |
| Constructeur / Fonction virtuelle | Les constructeurs peuvent être surchargés. | La fonction virtuelle peut être remplacée. |
| Destructeur | Le destructeur ne peut pas être surchargé. | Le destructeur peut être remplacé. |
| Contraignant | La surcharge permet une liaison précoce. | Le dépassement fait référence à une liaison tardive. |
Définition de la surcharge
Le polymorphisme au moment de la compilation est appelé "surcharge". La surcharge étant générée à partir d'un concept de polymorphisme, elle fournit «une interface commune pour plusieurs méthodes». Cela signifie que si une fonction est surchargée, elle contient le même nom de fonction tant qu’elle est redéfinie.
Les fonctions surchargées diffèrent par le nombre ou le type de paramètre (s), ce qui rend une fonction surchargée distincte d'une autre. De cette manière, le compilateur reconnaît quelle fonction surchargée est appelée. Les fonctions les plus souvent surchargées sont des «constructeurs». Le «constructeur de copie» est une sorte de «surcharge de constructeur».
Implémentation de la surcharge en C ++
surcharge de classe {int a, b; public: int load (int x) {// premier load () function a = x; retourne un; } int load (int x, int y) {// deuxième load () function a = x; b = y; retourne a * b; }}; int main () {surcharge O1; O1.load (20); // premier appel de la fonction load () O1.load (20, 40); // deuxième appel de la fonction load ()} Ici, la fonction load () de surcharge de classe a été surchargée. Les deux fonctions surchargées de la classe peuvent être distinguées de manière à ce que la première fonction load () n'accepte qu'un seul paramètre entier, alors que la seconde fonction load () accepte deux paramètres entiers. Lorsque l'objet de la surcharge de classe appelle la fonction load () avec un seul paramètre, la première fonction load () est appelée. Lorsque l'objet appelle la fonction load () en passant deux paramètres, la seconde fonction load () est appelée.
Définition de dérogation
Le polymorphisme obtenu au cours de l'exécution est appelé "priorité". Cela est accompli en utilisant "héritage" et "fonctions virtuelles". La fonction à remplacer est précédée du mot clé 'virtual' dans une classe de base et redéfinie dans une classe dérivée sans mot clé.
Une des choses les plus importantes à retenir en cas de dépassement est que le prototype de la fonction remplacée ne doit pas changer pendant que la classe dérivée le redéfinit. Lorsque la fonction remplacée reçoit un appel, C ++ détermine quelle version de la fonction est appelée en fonction du "type de l'objet pointé par un pointeur" à l'aide duquel l'appel de fonction est effectué.
Implémentation de la dérogation en C ++
class base {public: virtual void funct () {// fonction virtuelle de la classe de base cout << "Ceci est une fonction de la classe de base funct ()"; }}; class dérivée1: base publique {public: void funct () {// fonction virtuelle de la classe de base redéfinie dans la classe dérivée1 << - Il s'agit de la fonction funct () d'une classe dérivée1 »; }}; classe dérivée2: base publique {public: void funct () {// fonction virtuelle de la classe de base redéfinie dans la classe dérivée2 funct (); // appel à la classe dérivée1 funct (). * p = & d2; p-> funct (); // appel à la classe dérivée2 funct (). retourne 0; } Ici, il existe une seule classe de base qui est héritée publiquement par deux classes dérivées. Une fonction virtuelle est définie dans une classe de base avec un mot clé "virtual" et elle est redéfinie par les deux classes dérivées sans mot clé. Dans main (), la classe de base crée une variable de pointeur 'p' et un objet 'b'; La classe 'dérivée1' crée un objet d1 et la classe dérivée2 crée un objet d2 '.
Désormais, l'adresse de l'objet 'b' de la classe de base est affectée au pointeur de la classe de base 'p'. 'p' appelle la fonction funct (), une fonction de la classe de base est donc appelée. Ensuite, l'adresse de l'objet de classe dérivée1 'd1' est affectée au pointeur 'p', elle appelle à nouveau funct (); Ici, la fonction funct () de la classe dérivée1 est exécutée. Enfin, le pointeur 'p' est affecté à l'objet de la classe dérivée2. Puis 'p' appelle la fonction funct () qui exécute la fonction func () de la classe dérivée2.
Si la classe dérivée1 / dérivée2 ne redéfinissait pas funct (), le funct () de la classe de base aurait été appelé, car les fonctions virtuelles sont 'hiérarchiques'.
Principales différences entre la surcharge et la dérogation
- Le prototype d'une fonction surchargée diffère en raison du type et du nombre de paramètres transmis à la fonction surchargée. D'autre part, le prototype de la fonction remplacée ne change pas car une fonction remplacée exécute une action différente pour une classe différente à laquelle elle appartient mais avec le même type et le même nombre de paramètres.
- Le nom de la fonction surchargée ne précède aucun mot-clé, alors que le nom d'une fonction remplacée précède uniquement le mot-clé «Virtual» dans la classe de base.
- La fonction surchargée appelée est fonction du type ou du nombre de paramètres transmis à la fonction. La fonction substituée de la classe invoquée dépend de l'adresse de l'objet de la classe affectée au pointeur qui a appelé la fonction.
- La fonction surchargée qui doit être appelée est résolue pendant la compilation. La fonction remplacée à invoquer est résolue pendant l'exécution.
- Les constructeurs peuvent être surchargés mais ne peuvent pas être surchargés.
- Les destructeurs ne peuvent pas être surchargés, mais ils peuvent être remplacés.
- La surcharge permet une liaison précoce, car la fonction surchargée qui sera appelée est résolue pendant la compilation. La substitution entraîne une liaison tardive car la fonction qui est appelée à être invoquée est résolue pendant l'exécution.
Similitudes
- Les deux sont appliqués aux fonctions membres d'une classe.
- Le polymorphisme est le concept de base derrière les deux.
- Le nom de la fonction reste le même lorsque nous appliquons une surcharge et une substitution aux fonctions.
Conclusion
La surcharge et le dépassement semblent similaires, mais ce n'est pas le cas. Les fonctions peuvent être surchargées, mais aucune classe ne peut redéfinir la fonction surchargée à l'avenir. Une fonction virtuelle ne peut pas être surchargée; ils peuvent seulement être remplacés.
