logo

Fonctions en C++

Une fonction est un ensemble d'instructions qui prend en compte des données, effectue des calculs spécifiques, et produit une sortie. L'idée est d'en mettre de façon commune ou répétée effectué des tâches ensemble pour créer un fonction de sorte qu'au lieu d'écrire le même code encore et encore pour différentes entrées, nous pouvons appeler cette fonction.
En termes simples, une fonction est un bloc de code qui s’exécute uniquement lorsqu’elle est appelée.

Syntaxe:



Syntaxe de la fonction

Syntaxe de la fonction

Exemple:

C++








// C++ Program to demonstrate working of a function> #include> using> namespace> std;> // Following function that takes two parameters 'x' and 'y'> // as input and returns max of two input numbers> int> max(>int> x,>int> y)> {> >if> (x>y)> >return> x;> >else> >return> y;> }> // main function that doesn't receive any parameter and> // returns integer> int> main()> {> >int> a = 10, b = 20;> >// Calling above function to find max of 'a' and 'b'> >int> m = max(a, b);> >cout <<>'m is '> << m;> >return> 0;> }>

>

>

Sortir

m is 20>

Complexité temporelle : O(1)

Complexité spatiale : O(1)

Pourquoi avons-nous besoin de fonctions ?

  • Les fonctions nous aident à réduire la redondance du code . Si la fonctionnalité est exécutée à plusieurs endroits dans le logiciel, plutôt que d'écrire le même code encore et encore, nous créons une fonction et l'appelons partout. Cela facilite également la maintenance, car nous devons apporter des modifications à un seul endroit si nous apportons des modifications à la fonctionnalité à l'avenir.
  • Les fonctions créent du code modulaire . Considérons un gros fichier contenant de nombreuses lignes de code. Il devient vraiment simple de lire et d’utiliser le code si le code est divisé en fonctions.
  • Les fonctions fournissent abstraction . Par exemple, nous pouvons utiliser les fonctions de la bibliothèque sans nous soucier de leur travail interne.

Déclaration de fonction

Une déclaration de fonction indique au compilateur le nombre de paramètres, les types de données des paramètres et renvoie le type de fonction. L'écriture des noms de paramètres dans la déclaration de fonction est facultative mais il est nécessaire de les mettre dans la définition. Vous trouverez ci-dessous un exemple de déclarations de fonctions. (les noms de paramètres ne sont pas présents dans les déclarations ci-dessous)

Déclaration de fonction en C++

Déclaration de fonction

Exemple:

C++




// C++ Program to show function that takes> // two integers as parameters and returns> // an integer> int> max(>int>,>int>);> // A function that takes an int> // pointer and an int variable> // as parameters and returns> // a pointer of type int> int>* swap(>int>*,>int>);> // A function that takes> // a char as parameter and> // returns a reference variable> char>* call(>char> b);> // A function that takes a> // char and an int as parameters> // and returns an integer> int> fun(>char>,>int>);>

>

>

Types de fonctions

Types de fonctions en C++

Types de fonctions en C++

Fonction définie par l'utilisateur

Les fonctions définies par l'utilisateur sont des blocs de code définis par l'utilisateur/client et spécialement personnalisés pour réduire la complexité des gros programmes. Ils sont aussi communément appelés des fonctions sur mesure qui sont construits uniquement pour satisfaire la condition dans laquelle l'utilisateur est confronté à des problèmes tout en réduisant la complexité de l'ensemble du programme.

Fonction de bibliothèque

Les fonctions de bibliothèque sont également appelées Fonctions intégrées . Ces fonctions font partie d'un package de compilateur déjà défini et consiste en une fonction spéciale avec des significations spéciales et différentes. La fonction intégrée nous donne un avantage car nous pouvons les utiliser directement sans les définir alors que dans la fonction définie par l'utilisateur, nous devons déclarer et définir une fonction avant de les utiliser.
Par exemple: sqrt(), setw(), strcat(), etc.

Passage de paramètres aux fonctions

Les paramètres passés à la fonction sont appelés paramètres réels . Par exemple, dans le programme ci-dessous, 5 et 10 sont des paramètres réels.
Les paramètres reçus par la fonction sont appelés paramètres formels . Par exemple, dans le programme ci-dessus, x et y sont des paramètres formels.

Paramètre formel et paramètre réel en C++

Paramètre formel et paramètre réel

Il existe deux manières les plus courantes de transmettre des paramètres :

  1. Passer par valeur : Dans cette méthode de passage de paramètres, les valeurs des paramètres réels sont copiées dans les paramètres formels de la fonction. Les paramètres réels et formels sont stockés dans différents emplacements de mémoire, de sorte que les modifications apportées aux fonctions ne sont pas reflétées dans les paramètres réels de l'appelant.
  2. Passer par référence : Les paramètres réels et formels font référence aux mêmes emplacements, de sorte que toute modification apportée à l'intérieur de la fonction est reflétée dans les paramètres réels de l'appelant.

Définition de la fonction

Passer par valeur est utilisé lorsque la valeur de x n'est pas modifiée à l'aide de la fonction fun().

C++




// C++ Program to demonstrate function definition> #include> using> namespace> std;> void> fun(>int> x)> {> >// definition of> >// function> >x = 30;> }> int> main()> {> >int> x = 20;> >fun(x);> >cout <<>'x = '> << x;> >return> 0;> }>

>

>

Sortir

x = 20>

Complexité temporelle : O(1)

Complexité spatiale : O(1)

Fonctions utilisant des pointeurs

La fonction fun() attend un pointeur ptr vers un entier (ou l'adresse d'un entier). Il modifie la valeur à l'adresse ptr. L'opérateur de déréférencement * est utilisé pour accéder à la valeur à une adresse. Dans l'instruction « *ptr = 30 », la valeur à l'adresse ptr est modifiée en 30. L'opérateur d'adresse & est utilisé pour obtenir l’adresse d’une variable de n’importe quel type de données. Dans l'instruction d'appel de fonction « fun(&x) », l'adresse de x est transmise afin que x puisse être modifié en utilisant son adresse.

C++




// C++ Program to demonstrate working of> // function using pointers> #include> using> namespace> std;> void> fun(>int>* ptr) { *ptr = 30; }> int> main()> {> >int> x = 20;> >fun(&x);> >cout <<>'x = '> << x;> >return> 0;> }>

>

>

Sortir

x = 30>

Complexité temporelle : O(1)

Complexité spatiale : O(1)

Différence entre appel par valeur et appel par référence en C++

Appel par valeur Appeler par référence
Une copie de la valeur est transmise à la fonction Une adresse de valeur est passée à la fonction
Les modifications apportées à l'intérieur de la fonction ne sont pas
réfléchi sur d'autres fonctions
Les modifications apportées à l'intérieur de la fonction sont reflétées
en dehors de la fonction également
Des arguments réels et formels seront créés à
emplacement mémoire différent
Des arguments réels et formels seront créés à
même emplacement mémoire.

Points à retenir sur les fonctions en C++

1. La plupart des programmes C++ ont une fonction appelée main() qui est appelée par le système d'exploitation lorsqu'un utilisateur exécute le programme.

2. Chaque fonction a un type de retour. Si une fonction ne renvoie aucune valeur, alors void est utilisé comme type de retour. De plus, si le type de retour de la fonction est vide, nous pouvons toujours utiliser l'instruction return dans le corps de la définition de la fonction en ne spécifiant aucune constante, variable, etc., en mentionnant uniquement l'instruction 'return;' symboliser la fin de la fonction comme indiqué ci-dessous :

C++




void> function name(>int> a)> {> >.......>// Function Body> >return>;>// Function execution would get terminated> }>

>

>

3. Pour déclarer une fonction qui ne peut être appelée que sans aucun paramètre, il faut utiliser vider le plaisir (vide) . En remarque, en C++, une liste vide signifie qu'une fonction ne peut être appelée que sans aucun paramètre. En C++, void fun() et void fun(void) sont identiques.

Fonction principale

La fonction principale est une fonction spéciale. Chaque programme C++ doit contenir une fonction nommée main. Il sert de point d’entrée au programme. L'ordinateur commencera à exécuter le code depuis le début de la fonction principale.

Types de fonctions principales

1. Sans paramètres :

RPC




// Without Parameters> int> main() { ...>return> 0; }>

>

>

2. Avec paramètres :

RPC




// With Parameters> int> main(>int> argc,>char>*>const> argv[]) { ...>return> 0; }>

>

>

La raison d'avoir l'option de paramètre pour la fonction principale est de permettre la saisie à partir de la ligne de commande. Lorsque vous utilisez la fonction main avec des paramètres, elle enregistre chaque groupe de caractères (séparés par un espace) après le nom du programme en tant qu'éléments dans un tableau nommé argv .
Puisque la fonction principale a le type de retour de int , le programmeur doit toujours avoir une instruction return dans le code. Le numéro renvoyé est utilisé pour informer le programme appelant quel a été le résultat de l’exécution du programme. Renvoyer 0 signale qu’il n’y a eu aucun problème.

Récursivité C++

Lorsqu’une fonction est appelée dans la même fonction, on parle de récursivité en C++. La fonction qui appelle la même fonction est appelée fonction récursive.
Une fonction qui s’appelle elle-même et n’effectue aucune tâche après l’appel de fonction est appelée récursivité de queue. En récursion de queue, nous appelons généralement la même fonction avec l'instruction return.
Syntaxe:

C++




recursionfunction()> {> >recursionfunction();>// calling self function> }>

>

>

Pour en savoir plus voir Cet article .

C++ Passer un tableau à une fonction

En C++, pour réutiliser la logique des tableaux, on peut créer une fonction. Pour transmettre un tableau à une fonction en C++, nous devons fournir uniquement le nom du tableau.

function_name(array_name[]);   //passing array to function>

Exemple : Imprimez le nombre minimum dans le tableau donné.

C++




#include> using> namespace> std;> void> printMin(>int> arr[5]);> int> main()> {> >int> ar[5] = { 30, 10, 20, 40, 50 };> >printMin(ar);>// passing array to function> }> void> printMin(>int> arr[5])> {> >int> min = arr[0];> >for> (>int> i = 0; i <5; i++) {> >if> (min>arr[je]) {> >min = arr[i];> >}> >}> >cout <<>'Minimum element is: '> << min <<>' '>;> }> // Code submitted by Susobhan Akhuli>

>

>

Sortir

Minimum element is: 10>

Complexité temporelle : O(n) où n est la taille du tableau
Complexité spatiale : O(n) où n est la taille du tableau.

Surcharge C++ (Fonction)

Si nous créons deux membres ou plus ayant le même nom mais différents en nombre ou en type de paramètres, on parle de surcharge C++. En C++, on peut surcharger :

  • méthodes,
  • constructeurs et
  • propriétés indexées

Les types de surcharge en C++ sont :

  • Surcharge de fonctions
  • Surcharge des opérateurs

Surcharge de fonctions C++

La surcharge de fonctions est définie comme le processus consistant à avoir deux fonctions ou plus portant le même nom, mais des paramètres différents. En cas de surcharge de fonction, la fonction est redéfinie en utilisant soit différents types, soit différents nombres d'arguments. Ce n'est que grâce à ces différences qu'un compilateur peut différencier les fonctions.
L’avantage de la surcharge de fonctions est qu’elle augmente la lisibilité du programme car vous n’avez pas besoin d’utiliser des noms différents pour la même action.

Exemple : modification du nombre d'arguments de la méthode add()

C++




// program of function overloading when number of arguments> // vary> #include> using> namespace> std;> class> Cal {> public>:> >static> int> add(>int> a,>int> b) {>return> a + b; }> >static> int> add(>int> a,>int> b,>int> c)> >{> >return> a + b + c;> >}> };> int> main(>void>)> {> >Cal C;>// class object declaration.> >cout << C.add(10, 20) << endl;> >cout << C.add(12, 20, 23);> >return> 0;> }> // Code Submitted By Susobhan Akhuli>

>

>

Sortir

30 55>

Complexité temporelle : O(1)
Complexité spatiale : O(1)

Exemple : lorsque le type des arguments varie.

C++




// Program of function overloading with different types of> // arguments.> #include> using> namespace> std;> int> mul(>int>,>int>);> float> mul(>float>,>int>);> int> mul(>int> a,>int> b) {>return> a * b; }> float> mul(>double> x,>int> y) {>return> x * y; }> int> main()> {> >int> r1 = mul(6, 7);> >float> r2 = mul(0.2, 3);> >cout <<>'r1 is : '> << r1 << endl;> >cout <<>'r2 is : '> << r2 << endl;> >return> 0;> }> // Code Submitted By Susobhan Akhuli>

>

json à partir d'un objet Java
>

Sortir

r1 is : 42 r2 is : 0.6>

Complexité temporelle : O(1)
Complexité spatiale : O(1)

Surcharge de fonctions et ambiguïté

Lorsque le compilateur est incapable de décider quelle fonction doit être invoquée parmi la fonction surchargée, cette situation est appelée fonction surchargeant l'ambiguïté.
Lorsque le compilateur affiche l'erreur d'ambiguïté, le compilateur n'exécute pas le programme.

Causes de l'ambiguïté :

  • Conversion de types.
  • Fonction avec des arguments par défaut.
  • Fonction avec passage par référence.

Conversion de types : -

C++




#include> using> namespace> std;> void> fun(>int>);> void> fun(>float>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>float> j)> {> >cout <<>'Value of j is : '> << j << endl;> }> int> main()> {> >fun(12);> >fun(1.2);> >return> 0;> }> // Code Submitted By Susobhan Akhuli>

>

>

L'exemple ci-dessus montre une erreur l’appel du « fun(double) » surchargé est ambigu . Le fun(10) appellera la première fonction. Le fun(1.2) appelle la deuxième fonction selon notre prédiction. Mais cela ne fait référence à aucune fonction comme en C++, toutes les constantes à virgule flottante sont traitées comme des doubles et non comme des float. Si nous remplaçons float par double, le programme fonctionne. Il s’agit donc d’une conversion de type de float en double.

Fonction avec des arguments par défaut : -

C++




#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>,>int>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>int> a,>int> b = 9)> {> >cout <<>'Value of a is : '> << a << endl;> >cout <<>'Value of b is : '> << b << endl;> }> int> main()> {> >fun(12);> >return> 0;> }> // Code Submitted By Susobhan Akhuli>

>

>

L'exemple ci-dessus montre une erreur l'appel de 'fun(int)' surchargé est ambigu . Le fun(int a, int b=9) peut être appelé de deux manières : la première consiste à appeler la fonction avec un argument, c'est-à-dire fun(12), et une autre manière consiste à appeler la fonction avec deux arguments, c'est-à-dire fun(4). ,5). La fonction fun(int i) est invoquée avec un seul argument. Par conséquent, le compilateur n'a pas pu choisir entre fun(int i) et fun(int a,int b=9).

Fonction avec Pass By Reference : -

C++




#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>&);> int> main()> {> >int> a = 10;> >fun(a);>// error, which fun()?> >return> 0;> }> void> fun(>int> x) { cout <<>'Value of x is : '> << x << endl; }> void> fun(>int>& b)> {> >cout <<>'Value of b is : '> << b << endl;> }> // Code Submitted By Susobhan Akhuli>

>

>

L'exemple ci-dessus montre une erreur l'appel de 'fun(int&)' surchargé est ambigu . La première fonction prend un argument entier et la deuxième fonction prend un paramètre de référence comme argument. Dans ce cas, le compilateur ne sait pas quelle fonction est nécessaire à l'utilisateur car il n'y a pas de différence syntaxique entre fun(int) et fun(int &).

Fonction ami

  • Une fonction ami est une fonction spéciale en C++ qui, bien qu'elle ne soit pas une fonction membre d'une classe, a le privilège d'accéder aux données privées et protégées d'une classe.
  • Une fonction ami est une fonction non membre ou une fonction ordinaire d'une classe, qui est déclarée en utilisant le mot-clé ami à l'intérieur de la classe. En déclarant une fonction comme amie, toutes les autorisations d'accès sont données à la fonction.
  • Le mot-clé ami est placé uniquement dans la déclaration de fonction mais pas dans la définition de fonction.
  • Lorsque la fonction ami est appelée, ni le nom de l'objet ni l'opérateur point ne sont utilisés. Cependant, il peut accepter l'objet comme argument dont il souhaite accéder à la valeur.
  • Une fonction ami peut être déclarée dans n'importe quelle section de la classe, c'est-à-dire publique, privée ou protégée.

Déclaration de la fonction ami en C++

Syntaxe:

class {   friend (argument/s); };>

Exemple_1 : Trouvez le plus grand de deux nombres à l'aide de la fonction Friend

C++




#include> using> namespace> std;> class> Largest {> >int> a, b, m;> public>:> >void> set_data();> >friend> void> find_max(Largest);> };> void> Largest::set_data()> {> >cout <<>'Enter the first number : '>;> >cin>> un;> >cout <<>' Enter the second number : '>;> >cin>>b;> }> void> find_max(Largest t)> {> >if> (t.a>t.b)> >t.m = t.a;> >else> >t.m = t.b;> >cout <<>' Largest number is '> << t.m;> }> int> main()> {> >Largest l;> >l.set_data();> >find_max(l);> >return> 0;> }>

>

>

Sortir

Enter the first number : 789 Enter the second number : 982 Largest number is 982>