Introduction à la surcharge et à la surcharge en C ++
Commençons par avoir les définitions de base pour la surcharge et la substitution en C ++.
Surcharge : Le nom de la fonction est le même mais les paramètres et les retours de type changent. Puisque nous apprendrons à connaître la différence entre les fonctions surchargées pendant la compilation, cela s'appelle également le polymorphisme de compilation.
Remplacement: il s'agit d'une fonctionnalité du langage de programmation orientée objet où la fonction de la classe enfant porte le même nom que la fonction de classe du parent. Lorsque la fonctionnalité prioritaire apparaît dans l'image une fois l'objet déclaré et les fonctions accessibles à l'aide des objets; c'est-à-dire lors de l'exécution du code, ce concept de substitution est également appelé polymorphisme d'exécution.
Nous avons leur syntaxe et leurs méthodes de programmation dans les sections suivantes.
Syntaxe de surcharge et de surcharge
Voici la syntaxe de la surcharge et du remplacement donnée ci-dessous.
Syntaxe de surcharge:
return_type function_name ( int param_1, string param_2)
(
//function definition
)
return_type_2 function_name ( int param_1, string param_2)
(
//function definition
)
return_type function_name ( int param_1, int param_2)
(
//function definition
)
Tous les trois ensemble peuvent former un exemple du concept de surcharge.
Substitution de la syntaxe:
Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);Class B : Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);
Ce qui précède est la syntaxe de la fonctionnalité prioritaire. Le résultat principal peut être déduit une fois que nous déclarons un objet et appelons ces mêmes méthodes de la classe A et de la classe B. Dans la fonctionnalité de redéfinition de «l'objet» joue un rôle important.
Voyons maintenant un exemple pour mieux connaître leurs fonctionnalités.
Exemples de surcharge et de remplacement en C ++
Voici les exemples de surcharge et de surcharge en C ++ avec la sortie donnée ci-dessous:
Exemple # 1 - Surcharge
Commençons par un programme simple.
Code:
#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)
Production:
Maintenant, que se passe-t-il si je donne des valeurs de type de données incorrectes pour les variables a, b?
Code:
int main()
(
int a = 10.8;
float b = 12;
calc(a);
calc(b);
calc(a, b);
)
Je n'ai changé que la partie principale du programme ci-dessus, alors voici la sortie.
production:
Il nous donne la sortie car il va convertir la valeur flottante en type de données int et nous donne la sortie.
Maintenant, comme exercice, vous pouvez essayer de changer le type de retour de fonction et les paramètres et jouer avec eux.
Exemple # 2 - Remplacer
Ci-dessous, nous pouvons avoir un exemple de fonctionnalité prioritaire en C ++.
Code:
#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)
Production:
Grâce au code ci-dessus, nous pouvons constater que lorsque la référence de l'objet de première classe est affectée à l'objet créé par rapport à notre deuxième classe. Et puis, lorsque nous avons accédé à la méthode de remplacement à l'aide de l'objet de la classe de base, nous pouvons clairement remarquer que la sortie de la classe dérivée a été affichée. Ce concept est appelé dérogation. Les première et deuxième classes sont respectivement la classe de base et la classe dérivée. La sortie de ce qui précède est un ci-dessous:
Comme exercice, pouvez-vous essayer de remplacer et de surcharger une fonction ensemble et de vérifier si cela est possible ou de vérifier comment la sortie se révèle être?
Comment ça marche?
Surcharge: Ici, il n'y a pas de point particulier que nous puissions avoir une note. Nous devons nous assurer que le type de retour ou les paramètres à l'intérieur de la fonction varient. Si nous regardons ci-dessus la structure de programmation, les fonctions sont déclarées en premier et leur implémentation est donnée.
Overriding: La syntaxe de l'héritage et l'implémentation des fonctions sont les points clés à noter ici. Dans l'exemple ci-dessus, nous pouvons remarquer que la déclaration de fonction avec le mot-clé public est assez différente.
Et en C ++, la définition de classe se termine par un point-virgule (;) et si nous devons hériter la classe de base de la classe enfant, nous utilisons le symbole deux-points (:). La fonctionnalité principale de remplacement est observée lorsque les objets sont déclarés et initialisés pour la classe. Après l'appel de fonctions à l'aide des objets, on peut alors clairement comprendre le concept de surcharge.
Les avantages
- Le principal avantage de ces surcharges et surcharges est le gain de temps.
- Économisez de l'espace mémoire.
- La lisibilité du code est augmentée.
- Ici, pour le concept de surcharge de fonction, nous pouvons utiliser différents mêmes noms de fonction pour différentes opérations en éliminant l'utilisation de noms de fonction différents.
- La flexibilité et la maintenabilité du code deviennent plus faciles.
- En cas de substitution, la classe enfant peut avoir des fonctions de classe parent et peut même avoir sa propre implémentation de cette fonction.
- Les objets peuvent être référencés et les fonctions de la classe parent et de la classe enfant sont accessibles par la classe enfant.
Conclusion
Nous avons maintenant clairement compris les concepts de surcharge et de surcharge. En surcharge, nous devons nous assurer que la différence dans les fonctions surchargées existe en fonction du type de retour ou des paramètres, bien que la définition de la fonction à l'intérieur soit identique ou différente.
Et dans le cas de la surcharge, puisqu'il s'agit d'un concept de programmation orienté objet, nous ne pouvons utiliser que sous forme de classes utilisant la fonctionnalité d'héritage.
Articles recommandés
Ceci est un guide de surcharge et de remplacement en C ++. Nous discutons ici de l'introduction, de son fonctionnement, de la syntaxe, des exemples et des avantages de la surcharge et du remplacement en C ++ avec l'implémentation de code. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Surcharge en C ++
- Surcharge vs remplacement
- Surcharger en PHP
- Remplacement en C ++
- Surcharge en Java
- Polymorphisme en Java
- Les 11 principales fonctionnalités et avantages de C ++
- Surcharger en Python | Fonction et règles