C++ Surchargement de fonctions

Deux ou plusieurs fonctions ayant le même nom mais des paramètres différents sont appelées fonctions surchargées. Dans cet article, vous découvrirez la surcharge de fonctions par exemple.

FonctionC'est une portion de code qui regroupe le code pour exécuter une tâche spécifique.

En C ++Dans la programmation, si le nombre ou le type des paramètres passés est différent, deux fonctions peuvent avoir le même nom.

Les fonctions qui ont un nombre ou un type de paramètres différents (ou les deux) sont appelées fonctions surchargées. Par exemple :

int test() {}
int test(int a) {}
float test(double a) {}
int test(int a, double b) {}

ici, toutes4fonctions sont des fonctions surchargées, car les paramètres passés à ces fonctions sont différents.

Notez que ces4les types de retour de cette fonction ne sont pas les mêmes. Les fonctions surchargées peuvent ou ne peuvent pas avoir des types de retour différents, mais elles doivent avoir des paramètres différents.

//　code d'erreur
int test(int a) {}
double test(int b){}

Même si les types de retour sont différents, mais le nombre et le type des paramètres passés à ces deux fonctions sont les mêmes. Par conséquent, le compilateur génère une erreur.

Exemple1：fonction surchargée

#include <iostream>
using namespace std;
void display(int);
void display(float);
void display(int, float);
int main() {
　　　　int a =　5;
　　　　float b =　5.5;
　　　　display(a);
　　　　display(b);
　　　　display(a, b);
　　　　return 0;
}
void display(int var) {
　　　　cout << "entiers : " << var << endl;
}
void display(float var) {
　　　　cout << "nombres à virgule flottante : " << var << endl;
}
void display(int var1, float var2) {
　　　　cout << "entiers : " << var1;
　　　　cout << " et nombres à virgule flottante :" << var2;
}

résultat de la sortie

entiers :　5
nombres à virgule flottante :　5.5
entiers :　5　et les nombres à virgule flottante :5.5

Ici, la fonction display() est appelée trois fois avec des types ou des nombres de paramètres différents.

Le type de retour de toutes ces fonctions est le même, mais ce n'est pas nécessaire.

Exemple2：fonction surchargée

//le programme calcule la valeur absolue
//valide pour les entiers et les nombres à virgule flottante
#include <iostream>
using namespace std;
int absolute(int);
float absolute(float);
int main() {
　　　　int a =　-5;
　　　　float b =　5.5;
　　　　
　　　　cout << "numérique " << a << " valeur absolue= " << absolute(a) << endl;
　　　　cout << "numérique " << b << " valeur absolue= " << absolute(b);
　　　　return 0;
}
int absolute(int var) {
　　　　　if (var < 0)
　　　　　　　　　var =　-var;
　　　　return var;
}
float absolute(float var) {
　　　　if (var < 0.0)
　　　　　　　　var =　-var;
　　　　return var;
}

résultat de la sortie

numérique　-5　valeur absolue=　5
numérique　5.5　valeur absolue=　5.5

Dans l'exemple ci-dessus, deux fonctions absolute() sont surchargées.

Ces deux fonctions prennent un seul paramètre. Mais, une fonction prend un entier comme paramètre, tandis que l'autre prend un float comme paramètre.

Lorsque vous appelez la fonction absolute() avec int en tant que paramètre, cette fonction est appelée :

int absolute(int var) {
　　　　　if (var < 0)
　　　　　　　　　var =　-var;
　　　　return var;
}

Lorsque vous appelez la fonction absolute() avec float en tant que paramètre, cette fonction est appelée :

float absolute(float var) {
　　　　if (var < 0.0)
　　　　　　　　var =　-var;
　　　　return var;
}