C++

Surcharge de fonction C++

Surcharge de fonction C++

C++ est un langage de programmation polyvalent et 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, etc. Cet article couvre la surcharge de fonctions pour obtenir un polymorphisme à la compilation dans le langage de programmation C++.

Qu'est-ce qu'une fonction?

Une fonction n'est rien de plus qu'un morceau de code spécifique qui exécute une tâche spécifique en fonction des entrées fournies, et elle 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 la réutiliser ultérieurement, soit dans le même programme, soit dans un programme différent.

Syntaxe de la fonction

Une fonction en C++ a la syntaxe suivante :

returnType nom_fonction (liste_paramètres)



return return_value;

Le returnType, la liste_paramètres et l'instruction return sont facultatifs. 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 fonctions 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. Avec l'aide de la fonction de surcharge de fonction, le polymorphisme au moment de la compilation peut être réalisé en C++.

Les fonctions peuvent être surchargées des manières suivantes :

  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. int addition (int a, int b)
  2. addition flottante (float f, gloat g)
  3. addition flottante (float f, int i)
  4. addition flottante (int i, float f)
  5. int addition (int a, int b, int c)
  6. addition flottante (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 auriez besoin d'écrire une fonction distincte [par exemple, addition_1(), addition_2() etc] pour chaque variation. Par exemple, vous devrez peut-être écrire addition_1() pour ajouter deux entiers, addition_2() pour ajouter deux flottants, 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 variantes de la fonction « addition() » tout en conservant 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. int addition (int a, int b)
  2. addition flottante (int a, int b)

Exemples

Maintenant que vous comprenez le concept de surcharge de fonction, nous allons passer en revue quelques exemples de programmes fonctionnels 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 illustrent la fonction de surcharge de fonction en C++.

Exemple 1 : Fonction simple

Dans cet exemple, nous allons montrer comment une fonction simple peut être définie et appelée en C++. Nous allons définir une classe appelée « Display » et une fonction publique appelée « display().» A partir de la fonction « main() », on appellera la fonction « display() » à l'aide de l'objet de classe « Display » (d).

#inclure
en utilisant l'espace de noms std ;
classe Affichage

Publique:
affichage vide()

cout << "Hello World!" << endl;

 ;
int main()

Afficher d ;
ré.affichage();
renvoie 0 ;

Exemple 2 : Fonction d'addition simple

Dans cet exemple, nous allons montrer comment définir une simple fonction « addition() » en C++. Nous allons définir une classe appelée "DemoAdd" et une fonction publique appelée "addition().» A partir de 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 "addition()" actuelle n'est capable d'ajouter que deux entiers.

Pour ajouter trois nombres entiers au lieu de deux, une fonction avec un nom différent, tel que "addition_1()", peut être définie. 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, i.e., "une addition().” Dans l'exemple suivant, nous verrons comment surcharger la fonction “addition()”.

#inclure
en utilisant l'espace de noms std ;
classe DemoAjouter

Publique:
int addition(int a, int b)

résultat int;
résultat = a + b;
renvoyer le résultat ;

 ;
int main()

DémoAjouter d;
int i1 = 10, i2 = 20, res;
res = d.addition(i1, i2) ;
cout << "Result = " << res << endl;
renvoie 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 allons surcharger la fonction "addition()" pour ajouter trois entiers. Ainsi, nous pourrons appeler la fonction « addition() » avec deux arguments entiers, ainsi que trois arguments entiers.

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

#inclure
en utilisant l'espace de noms std ;
classe DemoAjouter

Publique:
// Première définition de fonction d'addition()
int addition(int a, int b)

résultat int;
résultat = a + b;
renvoyer le résultat ;

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

résultat int;
résultat = a + b + c;
renvoyer le résultat ;

 ;
int main()

DémoAjouter d;
int i1 = 10, i2 = 20, i3 = 30, res1, res2;
res1 = d.addition(i1, i2) ; // addition() avec 2 paramètres
res2 = d.addition(i1, i2, i3) ; // addition() avec 3 paramètres
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
renvoie 0 ;

Exemple 4 : surcharge de fonction (2)

Dans les sections précédentes de cet article, vous avez appris que la surcharge de fonction peut être effectuée en fonction des différences de type de paramètre. 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 float.

#inclure
en utilisant l'espace de noms std ;
classe DemoAjouter

Publique:
// Première définition de l'addition()
int addition(int a, int b)

résultat int;
résultat = a + b;
renvoyer le résultat ;

// Définition de fonction surchargée
addition flottante (float f, float g)

résultat flottant ;
résultat = f + g;
renvoyer le résultat ;

 ;
int main()

DémoAjouter d;
entier i1 = 10, i2 = 20, res1;
flotteur f1 = 10.5, f2 = 20.7, res2;
res1 = d.addition(i1, i2) ; // addition(int a, int b) sera appelé
res2 = d.addition(f1, f2) ; // addition(float f, flat g) sera appelé
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
renvoie 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
en utilisant l'espace de noms std ;
classe DemoAjouter

Publique:
// Première définition de la fonction addition()
addition flottante(int a, float b)

résultat flottant ;
résultat = (flottant)a + b;
renvoyer le résultat ;

// Définition de la fonction surchargée de la fonction addition()
addition flottante (float a, int b)

résultat flottant ;
résultat = a + (flotteur)b ;
renvoyer le résultat ;

 ;
int main()

DémoAjouter d;
entier i1 = 10;
flotteur f1 = 10.5, res1, res2;
res1 = d.addition(i1, f1) ; // addition(int a, float b) sera appelé
res2 = d.addition(f1, i1) ; // addition(float a, int b) sera appelé
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
renvoie 0 ;

Conclusion

C++ est un langage de programmation polyvalent et flexible qui est largement utilisé dans divers domaines. Ce langage de programmation prend en charge le polymorphisme à la compilation et à l'exécution. Dans cet article, vous avez appris comment obtenir un polymorphisme au moment de la compilation en C++ à l'aide de la fonction de surcharge de fonction. Il s'agit d'une fonctionnalité très utile en C++ qui aide les programmeurs à écrire du code lisible. Cela peut également être utile pour écrire du code réutilisable.

WinMouse vous permet de personnaliser et d'améliorer le mouvement du pointeur de la souris sur un PC Windows
Si vous souhaitez améliorer les fonctions par défaut de votre pointeur de souris, utilisez un logiciel gratuit WinMouse. Il ajoute plus de fonctionnal...
Le bouton de clic gauche de la souris ne fonctionne pas sous Windows 10
Si vous utilisez une souris dédiée avec votre ordinateur portable ou de bureau mais que le le clic gauche de la souris ne fonctionne pas sur Windows 1...
Le curseur saute ou se déplace de manière aléatoire lors de la saisie dans Windows 10
Si vous constatez que le curseur de votre souris saute ou se déplace tout seul, automatiquement, au hasard lors de la saisie sur un ordinateur portabl...