C ++ Fonction surcharge

C ++ est un langage de programmation à usage général flexible. Ce langage de programmation a été créé à l'origine par Bjarne Stroustrup, un informaticien danois, en 1985. C ++ prend en charge le polymorphisme, l'héritage et plus. Cet article couvre la surcharge de la fonction pour atteindre le polymorphisme à temps de compilation dans le langage de programmation C ++.

Qu'est-ce qu'une fonction?

Une fonction n'est rien d'autre qu'un morceau de code spécifique qui effectue une tâche spécifique en fonction des entrées fournies, et il renvoie les résultats demandés à l'utilisateur sous la forme d'une sortie. Les fonctions sont utilisées pour éliminer le code répétitif dans les grandes bases de code.

Après avoir défini une fonction, vous pouvez le réutiliser à un moment ultérieur, soit dans le même programme ou dans un programme différent.

Syntaxe de fonction

Une fonction en C ++ a la syntaxe suivante:

returnType functionName (paramètre_list)

…
…
return return_value;

L'instruction returnType, Parameter_List et Return sont facultatives. Une fonction en C ++ peut renvoyer un maximum d'une valeur. Si une fonction ne renvoie aucune valeur, le returnType doit être défini comme void.

Qu'est-ce que la surcharge de fonction?

En C ++, plusieurs définitions de fonction peuvent avoir le même nom de fonction, mais avec des paramètres différents. C'est ce qu'on appelle la surcharge de fonction. À l'aide de la fonction de surcharge de fonction, le polymorphisme à temps de compilation peut être obtenu en C++.

Les fonctions peuvent être surchargées de la manière suivante:

1. Le nombre de paramètres peut être différent
2. Le type de données des paramètres peut être différent
3. La séquence des paramètres peut être différente

Cependant, la valeur de retour n'est pas prise en compte pour la surcharge de fonction.

Les fonctions suivantes sont surchargées:

1. Addition int (int a, int b)
2. ajout de flotteur (flottant F, Gloat G)
3. ajout de flotteur (float f, int i)
4. ajout de flotteur (int i, float f)
5. Addition int (int a, int b, int c)
6. ajout de flotteur (float f, float g, float h)

Comme vous pouvez le voir, avec l'aide de la fonction de surcharge de fonction en C ++, il peut y avoir plusieurs définitions / fonctionnalités avec le même nom de fonction et dans la même portée.

Sans la fonction de surcharge de fonction, vous devrez écrire une fonction distincte [par exemple, ajout_1 (), ajout_2 () etc] pour chaque variation. Par exemple, vous devrez peut-être écrire addition_1 () pour ajouter deux entiers, addition_2 () pour ajouter deux flotteurs, et ainsi de suite. Cependant, comme vous pouvez le voir ci-dessus, la fonction de surcharge de fonction peut être utilisée pour définir plusieurs variations de la fonction «Addition ()» tout en gardant le même nom de fonction.

Les fonctions suivantes ne sont pas considérées comme surchargées car la seule différence entre ces deux est le type de retour (le type de retour n'est pas pris en compte pour la surcharge de fonction en C ++):

1. Addition int (int a, int b)
2. ajout de flotteur (int a, int b)

Exemples

Maintenant que vous comprenez le concept de surcharge de fonctions, nous allons passer par quelques programmes d'exemples de travail pour comprendre ce concept plus clairement. Nous couvrirons les exemples suivants:

1. Exemple 1: fonction simple
2. Exemple 2: fonction d'addition simple
3. Exemple 3: surcharge de fonction (1)
4. Exemple 4: surcharge de fonction (2)
5. Exemple 5: surcharge de fonction (3)

Les deux premiers exemples expliquent comment fonctionnent les fonctions normales en C ++, tandis que les trois derniers exemples démontrent la fonction de surcharge de fonction en C++.

Exemple 1: fonction simple

Dans cet exemple, nous montrerons comment une fonction simple peut être définie et appelée en C++. Nous définirons une classe appelée «affichage» et une fonction publique appelée «Display ()."D'après la fonction" Main () ", nous appellerons la fonction" Display () "à l'aide de l'objet de classe" Affichage "(D).

#inclure
Utilisation de Namespace Std;
affichage de classe

public:
void display ()
couter << "Hello World!" << endl;

;
int main()

Afficher d;
d.afficher();
retour 0;

Exemple 2: fonction d'addition simple

Dans cet exemple, nous montrerons comment définir une fonction «Addition ()» simple en C++. Nous définirons une classe appelée «Demoadd» et une fonction publique appelée «Add ().«D'après la fonction« main () », nous appellerons la fonction« Addition () »à l'aide de l'objet de classe« Demoadd »(D).

Dans cet exemple, l'implémentation actuelle de la fonction «addition ()» n'accepte que deux paramètres entiers. Cela signifie que la fonction actuelle «addition ()» est capable d'ajouter seulement deux entiers.

Pour ajouter trois entiers au lieu de deux, une fonction avec un nom différent, tel que «addition_1 ()», peut être défini. En C ++, une fonction peut être surchargée, ce qui signifie qu'une autre définition de la fonction «Addition ()» peut être définie pour ajouter trois entiers et garder le même nom, je.e., "ajout()."Dans l'exemple suivant, nous examinerons comment surcharger la fonction" addition () ".

#inclure
Utilisation de Namespace Std;
Demoadd de classe

public:
int ajout (int a, int b)
Résultat int;
résultat = a + b;
Résultat de retour;

;
int main()
Demoadd d;
int i1 = 10, i2 = 20, res;
res = D.ajout (i1, i2);
couter << "Result = " << res << endl;
retour 0;

Exemple 3: surcharge de fonction (1)

Dans l'exemple précédent, nous avons défini la fonction «Addition ()» pour ajouter deux entiers et renvoyer le résultat calculé. Maintenant, dans cet exemple, nous surchargerons la fonction «Addition ()» pour ajouter trois entiers. Nous serons donc en mesure d'appeler la fonction «Addition ()» avec deux arguments entiers, ainsi que trois arguments entiers.

Sans la fonction de surcharge de fonction, nous devions écrire une autre fonction avec un nom différent.

#inclure
Utilisation de Namespace Std;
Demoadd de classe

public:
// Définition de la première fonction d'addition ()
Addition int (int a, int b)

Résultat int;
résultat = a + b;
Résultat de retour;

// Version surchargée de la fonction ADD ()
Addition int (int a, int b, int c)

Résultat int;
résultat = a + b + c;
Résultat de retour;

;
int main()

Demoadd d;
int i1 = 10, i2 = 20, i3 = 30, res1, res2;
res1 = d.ajout (i1, i2); // ajout () avec 2 paramètres
res2 = d.addition (i1, i2, i3); // ajout () avec 3 paramètres
couter << "Result = " << res1 << endl;
couter << "Result = " << res2 << endl;
retour 0;

Exemple 4: surcharge de fonction (2)

Dans les sections antérieures de cet article, vous avez appris que la surcharge de fonctions peut être effectuée en fonction des différences de type de paramètres. Ici, nous avons surchargé la fonction «addition ()» en fonction du type de données du paramètre. Dans la première version de la fonction d'addition, nous ajouterons deux variables de type entier; Et dans la deuxième version, nous ajouterons deux variables de type flotteur.

#inclure
Utilisation de Namespace Std;
Demoadd de classe

public:
// Première définition de l'ajout ()
Addition int (int a, int b)

Résultat int;
résultat = a + b;
Résultat de retour;

// Définition de la fonction surchargée
ajout de flotteur (float f, float g)

Résultat flottant;
résultat = f + g;
Résultat de retour;

;
int main()
Demoadd d;
int i1 = 10, i2 = 20, res1;
float f1 = 10.5, f2 = 20.7, res2;
res1 = d.ajout (i1, i2); // addition (int a, int b) sera appelé
res2 = d.addition (F1, F2); // ajout (float f, plat g) sera appelé
couter << "Result = " << res1 << endl;
couter << "Result = " << res2 << endl;
retour 0;

Exemple 5: surcharge de fonction (3)

Dans cet exemple, la fonction «Addition ()» est surchargée en fonction des différences dans la séquence de la liste des paramètres. C'est une autre façon de surcharger une fonction en C++.

#inclure
Utilisation de Namespace Std;
Demoadd de classe

public:
// Fonction de la première fonction de la fonction ajout ()
Ajout de flotteur (int a, float b)

Résultat flottant;
résultat = (float) a + b;
Résultat de retour;

// Fonction surchargée Définition de la fonction Addition ()
ajout de flotteur (flotteur A, int b)

Résultat flottant;
result = a + (float) b;
Résultat de retour;

;
int main()

Demoadd d;
int i1 = 10;
float f1 = 10.5, res1, res2;
res1 = d.addition (I1, F1); // ajout (int a, float b) sera appelé
res2 = d.addition (F1, I1); // ajout (float a, int b) sera appelé
couter << "Result = " << res1 << endl;
couter << "Result = " << res2 << endl;
retour 0;

Conclusion

C ++ est un langage de programmation à usage général et flexible qui est largement utilisé dans divers domaines. Ce langage de programmation prend en charge à la fois le polymorphisme de compilation et d'exécution. Dans cet article, vous avez appris à atteindre le polymorphisme de compilation en temps. Ceci est une fonctionnalité très utile en C ++ qui aide les programmeurs à écrire du code lisible. Il peut également être utile pour écrire du code réutilisable.