Introduction à la surcharge de fonctions en C ++
La programmation C ++ a des fonctionnalités incroyables et l'une des fonctionnalités les plus importantes est la surcharge de fonctions. Cela signifie un code ayant plus d'une fonction avec le même nom mais avec les différentes listes d'arguments. La liste d'arguments signifie la séquence des arguments et les types de données des arguments. La surcharge de fonctions est utilisée pour effectuer des opérations similaires. Il est utilisé pour améliorer la lisibilité du code. Redéfini la fonction car il est inutile de créer deux fonctions différentes pour effectuer le même travail encore et encore.
Syntaxe
void add(int a, int b);
void add(float a, float b);
Les deux sont la même fonction mais les arguments sont différents. Donc, si vous souhaitez effectuer un ajout sur différents types de données en utilisant la même fonction, la fonction de surcharge de fonction peut être utilisée dans la programmation avec C ++.
Voici le code C ++ pour illustrer la surcharge de fonctions dans la programmation C ++:
Code:
#include
using namespace std;
void print(int x) (
cout << " Here is the integer " << x << endl;
)
void print(double y) (
cout << " Here is the float " << y << endl;
)
void print(char const *v) (
cout << " Here is the character* " << v << endl;
)
int main() (
print(20);
print(20.30);
print("three");
return 0;
)
Différentes façons de surcharger la fonction en C ++
Il existe plusieurs façons de surcharger une fonction dans le langage de programmation C ++. Voyons comment faire ça:
1. Surcharge de fonction
Utilisez pour augmenter la lisibilité du code dans la programmation. Il peut être défini comme une surcharge de 2 fonctions ou plus portant le même nom, mais différents paramètres sont appelés surcharge de fonction.
Syntaxe:
DataType Functionname (parameter list)
(
Function body
)
Exemple 1
Voici le code C ++ pour illustrer la surcharge de fonctions en modifiant le nombre d'arguments dans la programmation C ++:
Code:
#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
static int addition(int a, int b)(
return a + b;
)
static int addition(int a, int b, int c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)
Exemple # 2
Voici le code C ++ pour illustrer la surcharge de fonctions en ayant différents types d'arguments dans la programmation C ++:
Code:
#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)#include
using namespace std;
class Calculate (
public:
int addition(int a, int b)(
return a + b;
)
float addition(float a, float b, float c)
(
return a + b + c;
)
);
int main(void) (
// Declaration class object to call function
Calculate S;
cout< cout< return 0;
)
2. Surcharge de l'opérateur
Il existe plusieurs opérateurs intégrés dans le langage de programmation C ++. Un codeur peut utiliser ces opérateurs pour surcharger ou redéfinir ces opérateurs intégrés. Il s'agit d'un polymorphisme à la compilation dans lequel un opérateur surchargé est utilisé pour effectuer des tâches sur des types de données définis par l'utilisateur. Presque de nombreux opérateurs peuvent être surchargés dans le langage de programmation C ++.
Syntaxe:
ReturnType Classname :: operator OperatorSymbol (parameter list)
(
Function body
)
Exemple 1
Voici le code C ++ pour illustrer la surcharge de l'opérateur dans la programmation C ++:
Code:
#include
using namespace std;
class Demo
(
private:
int count;
public:
Demo(): count(5)()
void operator ++()
(
count = count+1;
)
void DisplayCount() ( cout<<"The Count is : "< );
int main()
(
Demo d;
// this calls void operator ++()" function
++d;
d.DisplayCount();
return 0;
)#include
using namespace std;
class Demo
(
private:
int count;
public:
Demo(): count(5)()
void operator ++()
(
count = count+1;
)
void DisplayCount() ( cout<<"The Count is : "< );
int main()
(
Demo d;
// this calls void operator ++()" function
++d;
d.DisplayCount();
return 0;
)
Exemple # 2
Voyons comment fonctionne la surcharge de fonctions? en programmation à travers des exemples de codage C ++:
Code:
#include
using namespace std;
void show(int);
void show(float);
void show(int, float);
int main() (
int x = 10;
float y = 255.5;
show(x);
show(y);
show(x, y);
return 0;
)
void show(int variable) (
cout << "The Integer number is : " << variable << endl;
)
void show(float variable) (
cout << "The Float number is: " << variable << endl;
)
void show(int variable1, float variable2) (
cout << "The Integer number is: " << variable1;
cout << " And The Float number is:" << variable2;
)
Explication du code:
Dans le code ci-dessus, nous avons créé une fonction pour afficher la sortie de différents types de données, mais si vous remarquez que le nom des fonctions est le même et que les arguments sont différents. Ensuite, nous avons initialisé une variable appelée x et lui avons attribué une valeur et une valeur affectée à la variable flottante y également. Après avoir attribué des valeurs aux variables x et y, nous avons appelé la fonction indiquée pour afficher la valeur d'entrée sur l'écran de sortie.
Comme vous pouvez voir les noms des fonctions, mais l'argument est différent dans les trois cas. Tout d'abord, nous avons appelé la fonction afficher uniquement la variable entière après cela, nous avons appelé la fonction afficher pour afficher la sortie uniquement pour la variable flottante. Enfin, nous avons appelé la fonction show qui a à la fois des variables entières et flottantes pour afficher la sortie sur l'écran d'affichage en sortie.
C'est ainsi que fonctionne réellement la fonction de surcharge de fonctions dans le langage de programmation C ++. Selon différents types de données, la même fonction peut être utilisée pour effectuer un ensemble d'opérations similaire.
Exemple # 3
Voici le code C ++ pour illustrer la surcharge de fonctions dans la programmation C ++:
Code:
#include
using namespace std;
class X
( int x;
public:
X()()
X(int j)
(
x=j;
)
void operator+(X);
void display();
);
void X :: operator+(X a)
(
int n = x+ax;
cout<<"The addition of two objects is : "< )
int main()
(
X a1(505);
X a2(409);
a1+a2;
return 0;
)#include
using namespace std;
class X
( int x;
public:
X()()
X(int j)
(
x=j;
)
void operator+(X);
void display();
);
void X :: operator+(X a)
(
int n = x+ax;
cout<<"The addition of two objects is : "< )
int main()
(
X a1(505);
X a2(409);
a1+a2;
return 0;
)
Explication du code:
Dans le code ci-dessus, nous avons créé une classe X et créé une variable entière x, puis déclaré deux constructeurs afin de ne pas avoir à créer d'objets pour appeler la fonction en tant que constructeur initialise automatiquement un objet de classe nouvellement créé juste après l'allocation d'une mémoire . Deux fonctions sont créées par l'opérateur et l'affichage pour montrer l'ajout de deux objets à l'aide des concepts de surcharge de fonctions dans notre code.
Conclusion
En conclusion, la fonctionnalité de surcharge de fonction en C ++ peut être utilisée de plusieurs manières pour augmenter la lisibilité du code. Il permet d'économiser de l'espace mémoire ainsi que du temps de compilation lors de la programmation avec le langage C ++. Le concept de polymorphisme à la compilation est également introduit par le biais de concepts de surcharge d'opérateurs où presque tous les opérateurs peuvent être surchargés.
Articles recommandés
Ceci est un guide de la surcharge de fonctions en C ++. Ici, nous discutons des différentes façons de surcharger la fonction en C ++ avec différents exemples et implémentations de code. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Comment fonctionne la fonction récursive en C ++?
- 3 principaux types de données en C ++
- Exemples de surcharge et de remplacement en C ++
- Tableau de chaînes en C ++ un tableau de plusieurs chaînes