Menu

Fonctions en C ++ avec types et exemples

functions c with types examples

Essayez Notre Instrument Pour Éliminer Les Problèmes

Types de fonctions en C ++ avec leurs utilisations.

Dans nos tutoriels précédents jusqu'à présent, nous avons vu les différents concepts en C ++ comme les variables, les classes de stockage, les opérateurs, les tableaux, les chaînes, etc.

Dans ce tutoriel, nous allons avancer et discuter du concept de fonctions. Les fonctions sont également appelées méthodes, sous-programmes ou procédures.

=> Lisez la série complète de didacticiels de formation C ++ ici.

FONCTIONS EN C ++

Ce que vous apprendrez:

Comment définir une fonction?

Une fonction est un ensemble d'instructions assemblées pour effectuer une tâche spécifique. Il peut s'agir d'instructions exécutant certaines tâches répétées ou d'instructions exécutant certaines tâches spéciales telles que l'impression, etc.

Une utilisation des fonctions consiste à simplifier le code en le décomposant en unités plus petites appelées fonctions. Encore une autre idée derrière l'utilisation des fonctions est que cela nous évite d'écrire le même code encore et encore. Il suffit d'écrire une fonction et de l'appeler en cas de besoin sans avoir à écrire encore et encore le même ensemble d'instructions.

Types de fonctions en C ++

En C ++, nous avons deux types de fonctions comme indiqué ci-dessous.

Types de fonctions en C ++

Fonctions intégrées

Les fonctions intégrées sont également appelées fonctions de bibliothèque. Ce sont les fonctions fournies par C ++ et nous n'avons pas besoin de les écrire nous-mêmes. Nous pouvons directement utiliser ces fonctions dans notre code.

Ces fonctions sont placées dans les fichiers d'en-tête de C ++. Par exemple ,, sont les en-têtes qui ont respectivement des fonctions mathématiques et des fonctions de chaîne intégrées.

Voyons un exemple d'utilisation des fonctions intégrées dans un programme.

#include #include using namespace std; int main() { string name; cout << 'Enter the input string:'; getline (std::cin, name); cout << 'String entered: ' << name << '! '; int size = name.size(); cout<<'Size of string : '<

Production:

Entrez la chaîne d'entrée: Aide sur les tests de logiciels
Chaîne entrée: Aide au test de logiciels!
Taille de la chaîne: 21

Ici, nous utilisons les en-têtes et. Les types de données et les autres fonctions d'entrée / sortie sont définis dans la bibliothèque. Les fonctions de chaîne utilisées comme getline, size font partie de l'en-tête.

Fonctions définies par l'utilisateur

C ++ permet également à ses utilisateurs de définir leurs propres fonctions. Ce sont les fonctions définies par l'utilisateur. Nous pouvons définir les fonctions n'importe où dans le programme, puis appeler ces fonctions à partir de n'importe quelle partie du code. Tout comme les variables, elles doivent être déclarées avant d'être utilisées, les fonctions doivent également être déclarées avant d'être appelées.

Discutons en détail des fonctions définies par l'utilisateur.

La syntaxe générale des fonctions définies par l'utilisateur (ou simplement des fonctions) est la suivante:

return_type functionName(param1,param2,….param3) { Function body; }

Ainsi, comme indiqué ci-dessus, chaque fonction a:

  • Type de retour: C'est la valeur que les fonctions renvoient à la fonction appelante après avoir exécuté une tâche spécifique.
  • functionName : Identifiant utilisé pour nommer une fonction.
  • Liste des paramètres: Désigné par param1, param2,… paramn dans la syntaxe ci-dessus. Ce sont les arguments qui sont passés à la fonction lors d'un appel de fonction. La liste des paramètres est facultative, c'est-à-dire que nous pouvons avoir des fonctions qui n'ont pas de paramètres.
  • Corps de fonction: Un groupe d'énoncés qui exécutent une tâche spécifique.

Comme déjà mentionné, nous devons «déclarer» une fonction avant de l’utiliser.

Déclaration de fonction

Une déclaration de fonction indique au compilateur le type de retour de la fonction, le nombre de paramètres utilisés par la fonction et ses types de données. En incluant les noms des paramètres dans la fonction, la déclaration est facultative. La déclaration de fonction est également appelée comme prototype de fonction.

Nous avons donné quelques exemples de la déclaration de fonction ci-dessous pour votre référence.

int sum(int, int);

La déclaration ci-dessus est une fonction «somme» qui prend deux entiers comme paramètres et renvoie une valeur entière.

void swap(int, int);

Cela signifie que la fonction swap prend deux paramètres de type int et ne renvoie aucune valeur et que le type de retour est donc void.

void display();

L'affichage de la fonction ne prend aucun paramètre et ne renvoie aucun type.

Définition de fonction

Une définition de fonction contient tout ce qu'une déclaration de fonction contient et contient également le corps de la fonction entre accolades ({}).

De plus, il devrait également avoir des paramètres nommés. Lorsque la fonction est appelée, le contrôle du programme passe à la définition de la fonction afin que le code de fonction puisse être exécuté. Lorsque l'exécution de la fonction est terminée, le contrôle repasse au point où la fonction a été appelée.

Pour la déclaration ci-dessus de la fonction de swap, la définition est la suivante:

void swap(int a, int b){ b = a + b; a = b - a; b = b - a; }

Notez que la déclaration et la définition d'une fonction peuvent aller de pair. Si nous définissons une fonction avant de la référencer, il n'y a pas besoin d'une déclaration séparée.

Prenons un exemple de programmation complet pour démontrer une fonction.

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping: '; cout<<'a = '<
quels types d'applications nous testons

Dans la fonction main, nous lisons deux entiers puis appelons la fonction swap en lui passant ces deux entiers. Dans la fonction swap, les deux entiers sont échangés à l'aide d'une logique standard et les valeurs permutées sont imprimées.

Appeler une fonction

Lorsque nous avons une fonction dans notre programme, en fonction des besoins, nous devons appeler ou invoquer cette fonction. Ce n'est que lorsque la fonction est appelée ou invoquée que la fonction exécutera son ensemble d'instructions pour fournir les résultats souhaités.

La fonction peut être appelée de n'importe où dans le programme. Il peut être appelé à partir de la fonction principale ou de toute autre fonction si le programme utilise plus d'une fonction. La fonction qui appelle une autre fonction est appelée «fonction d'appel».

Dans l'exemple ci-dessus d'échange de numéros, la fonction swap est appelée dans la fonction principale. Par conséquent, la fonction principale devient la fonction d'appel.

Paramètres formels et réels

Nous avons déjà vu que nous pouvons avoir des paramètres pour les fonctions. Les paramètres de fonction sont fournis dans la définition de fonction sous forme de liste de paramètres qui suit le nom de la fonction. Lorsque la fonction est appelée, nous devons transmettre les valeurs réelles de ces paramètres afin qu'en utilisant ces valeurs réelles, la fonction puisse effectuer sa tâche.

Les paramètres définis dans la définition de fonction sont appelés Paramètres formels . Les paramètres de l'appel de fonction qui sont les valeurs réelles sont appelés Paramètres réels.

Dans l'exemple ci-dessus d'échange de numéros, nous avons écrit les commentaires pour les paramètres formels et réels. Dans la fonction appelante, c'est-à-dire main, la valeur de deux entiers est lue et transmise à la fonction d'échange. Ce sont les paramètres réels.

Nous pouvons voir les définitions de ces paramètres dans la première ligne de la définition de fonction. Ce sont les paramètres formels.

Notez que le type d'arguments formels et réels doit correspondre. L'ordre des paramètres formels et réels doit également correspondre.

Valeurs de retour

Une fois que la fonction a effectué sa tâche prévue, elle doit renvoyer le résultat à la fonction appelante. Pour cela, nous avons besoin du type de retour de la fonction. La fonction peut renvoyer une seule valeur à la fonction appelante. Le type de retour de la fonction est déclaré avec le prototype de la fonction.

Prenons un exemple d’ajout de deux nombres pour illustrer les types de retour.

#include using namespace std; int sum(int a, int b){ return (a+b); } int main() { int a, b, result; cout<>a>>b; result = sum(a,b); cout<<' Sum of the two numbers : '<

Production:

Entrez les deux chiffres à ajouter: 11 11

Somme des deux nombres: 22

Dans l'exemple ci-dessus, nous avons une fonction sum qui prend deux paramètres entiers et renvoie un type entier. Dans la fonction principale, nous lisons deux entiers à partir de l'entrée de la console et les passons à la fonction somme. Comme le type de retour est un entier, nous avons une variable de résultat sur le LHS et RHS est un appel de fonction.

meilleur logiciel de clonage pour windows 10

Lorsqu'une fonction est exécutée, l'expression (a + b) renvoyée par la fonction somme est affectée à la variable de résultat. Cela montre comment la valeur de retour de la fonction est utilisée.

Fonctions d'annulation

Nous avons vu que la syntaxe générale de la fonction nécessite la définition d'un type de retour. Mais si nous avons une telle fonction qui ne renvoie aucune valeur, dans ce cas, que spécifions-nous comme type de retour? La réponse est que nous utilisons le type sans valeur «void» pour indiquer que la fonction ne renvoie pas de valeur.

Dans un tel cas, la fonction est appelée «fonction vide» et son prototype sera comme

void functionName (param1, param2,… .param 3);

Noter : Il est considéré comme une bonne pratique d'inclure une déclaration «retour»; à la fin de la fonction vide pour plus de clarté.

Passage de paramètres aux fonctions

Nous avons déjà vu le concept de paramètres réels et formels. Nous savons également que les paramètres réels transmettent des valeurs à une fonction qui est reçue par les paramètres de format. C'est ce qu'on appelle le passage de paramètres.

En C ++, nous avons certaines façons de passer des paramètres comme indiqué ci-dessous.

Passer par valeur

Dans le programme d'échange de deux entiers dont nous avons discuté plus tôt, nous avons vu que nous lisions simplement les entiers «a» et «b» dans main et les passions à la fonction d'échange. C'est la technique du passage par valeur.

Dans la technique passe par valeur de passage de paramètres, les copies des valeurs des paramètres réels sont passées aux paramètres formels. Pour cette raison, les paramètres réels et formels sont stockés à différents emplacements de mémoire. Ainsi, les modifications apportées aux paramètres formels à l'intérieur de la fonction ne reflètent pas l'extérieur de la fonction.

Nous pouvons mieux comprendre cela en visitant à nouveau l'échange de deux numéros.

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping inside Swap: '; cout<<'a = '< a = 2 b = 3
Après avoir échangé dans Main:
a = 3 b = 2

Nous avons simplement modifié le programme précédent pour imprimer les valeurs des paramètres formels et des paramètres réels avant et après l'appel de fonction.

Comme vu de la sortie, nous transmettons initialement les valeurs a = 3 et b = 2. Ce sont les paramètres réels. Ensuite, après avoir permuté à l'intérieur de la fonction d'échange, nous voyons que les valeurs sont réellement permutées et a = 2 et b = 3.

Cependant, après l'appel de fonction à swap, dans la fonction principale, les valeurs de a et b sont toujours 3 et 2 respectivement. Cela est dû au fait que les paramètres réels sont passés à la fonction où il a une copie des variables. Par conséquent, bien que les paramètres formels aient été échangés dans la fonction d'échange, ils n'ont pas été reflétés.

Bien que la technique de passage par valeur soit la plus basique et la plus largement utilisée, en raison de la limitation ci-dessus, nous ne pouvons l'utiliser que dans les cas où nous n'avons pas besoin que la fonction change les valeurs lors de l'appel de la fonction.

Passer par référence

Le passage par référence est une autre technique utilisée par C ++ pour passer des paramètres aux fonctions. Dans cette technique, au lieu de transmettre des copies des paramètres réels, nous transmettons des références aux paramètres réels.

Noter: Les références ne sont que des alias de variables ou en mots simples, c'est un autre nom qui est donné à une variable. Par conséquent, une variable et sa référence partagent le même emplacement mémoire. Nous apprendrons les références en détail dans notre prochain tutoriel.

Dans la technique de passage par référence, nous utilisons ces références de paramètres réels et, par conséquent, les modifications apportées aux paramètres formels dans la fonction sont renvoyées à la fonction appelante.

Nous modifions notre fonction d'échange pour que nos lecteurs comprennent mieux le concept.

#include #include using namespace std; void swap(int &a, int &b){ int temp = a; a = b; b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Par conséquent, les modifications apportées aux paramètres formels dans la fonction d'échange se reflètent dans la fonction principale et nous obtenons les valeurs permutées.

Passer par le pointeur

En C ++, nous pouvons également passer des paramètres à une fonction à l'aide de variables de pointeur. La technique du passage par pointeur produit les mêmes résultats que celle du passage par référence. Cela signifie que les paramètres formels et réels partagent les mêmes emplacements de mémoire et les modifications apportées à la fonction sont reflétées dans la fonction appelante.

La seule différence que dans un passage par référence, nous traitons des références ou des alias de paramètres alors que dans une technique de passage par pointeur, nous utilisons des variables de pointeur pour passer les paramètres.

Les variables de pointeur diffèrent selon les références dans lesquelles les variables de pointeur pointent vers une variable particulière et contrairement aux références, nous pouvons changer la variable vers laquelle elle pointe. Nous explorerons les détails du pointeur dans nos tutoriels ultérieurs.

Nous présentons à nouveau l'échange de deux entiers pour démontrer la technique Pass by Pointer.

#include #include using namespace std; void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Paramètres par défaut

En C ++, nous pouvons fournir des valeurs par défaut pour les paramètres de fonction. Dans ce cas, lorsque nous appelons la fonction, nous ne spécifions pas de paramètres. Au lieu de cela, la fonction prend les paramètres par défaut fournis dans le prototype.

L'exemple suivant illustre l'utilisation des paramètres par défaut.

#include #include using namespace std; int mathoperation(int a, int b = 3, int c = 2){ return ((a*b)/c); } int main() { int a,b,c; cout<>a>>b>>c; cout<

Production:

Entrez les valeurs pour a, b et c: 10 4 6

Appel à mathopération avec 1 argument: 15
Appel à mathoperation avec 2 arg: 20
Appel à mathoperation avec 3 arguments: 6

Comme indiqué dans l'exemple de code, nous avons une fonction «matopération» qui prend trois paramètres parmi lesquels nous avons fourni des valeurs par défaut pour deux paramètres. Ensuite, dans la fonction principale, nous appelons cette fonction trois fois avec une liste d'arguments différente.

Le premier appel est avec un seul argument. Dans ce cas, les deux autres arguments auront des valeurs par défaut. Le prochain appel est avec deux arguments. Dans ce cas, le troisième argument aura une valeur par défaut. Le troisième appel est avec trois arguments. Dans ce cas, comme nous avons fourni les trois arguments, les valeurs par défaut seront ignorées.

Notez que tout en fournissant des paramètres par défaut, nous partons toujours du paramètre le plus à droite. De plus, nous ne pouvons pas ignorer un paramètre intermédiaire et fournir une valeur par défaut pour le paramètre suivant.

Passons maintenant à quelques concepts spéciaux liés aux fonctions qui sont importants du point de vue du programmeur.

Paramètres Const

Nous pouvons également passer des paramètres constants aux fonctions en utilisant le mot-clé «const». Lorsqu'un paramètre ou une référence est const, il ne peut pas être modifié dans la fonction.

Notez que nous ne pouvons pas passer un paramètre const à un paramètre formel non const. Mais nous pouvons passer des paramètres const et non-const à un paramètre formel const.

De même, nous pouvons également avoir un type de retour const. Dans ce cas également, le type de retour ne peut pas être modifié.

Voyons un exemple de code qui utilise des références const.

#include #include using namespace std; int addition(const int &a, const int &b){ return (a+b); } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Production:

Entrez les deux nombres à échanger: 22 33
a = 2 b = 33
Résultat de l'addition: 55

Dans le programme ci-dessus, nous avons des paramètres formels const. Notez que les paramètres réels sont des variables non const ordinaires que nous avons passées avec succès. Les paramètres formels étant const, nous ne pouvons pas les modifier à l'intérieur de la fonction. Nous effectuons donc simplement l'opération d'addition et retournons la valeur.

Si nous essayons de modifier les valeurs de a ou b dans la fonction, le compilateur émettra une erreur.

Fonctions en ligne

Nous savons que pour faire un appel de fonction, il s'agit en interne d'un compilateur stockant l'état du programme sur une pile avant de passer le contrôle à la fonction.

Lorsque la fonction revient, le compilateur doit récupérer l'état du programme et continuer là où il l'a laissé. Cela pose une surcharge. Par conséquent, en C ++ chaque fois que nous avons une fonction composée de quelques instructions, il existe une fonction qui lui permet de se développer en ligne. Cela se fait en créant une fonction en ligne.

Ainsi, les fonctions en ligne sont les fonctions qui sont développées au moment de l'exécution, ce qui évite les efforts pour appeler la fonction et effectuer les modifications de la pile. Mais même si nous créons une fonction en ligne, le compilateur ne garantit pas qu'elle sera développée au moment de l'exécution. En d'autres termes, il dépend entièrement du compilateur pour rendre la fonction en ligne ou non.

Certains compilateurs détectent des fonctions plus petites et les développent en ligne même si elles ne sont pas déclarées en ligne.

Voici un exemple de fonction en ligne.

inline int addition(const int &a,const int &b){ return (a+b); }

Comme indiqué ci-dessus, nous faisons précéder la définition de la fonction d'un mot-clé «inline» afin de rendre une fonction inline.

Utilisation de structures dans les fonctions

Nous pouvons passer des variables de structure en tant que paramètres pour fonctionner de la même manière que nous transmettons des variables ordinaires en tant que paramètres.

Ceci est illustré dans l'exemple suivant.

#include #include using namespace std; struct PersonInfo { int age; char name(50); double salary; }; void printStructInfo(PersonInfo p) { cout<<'PersonInfo Structure:'; cout<<' Age:'< p.age; cout <> p.salary; printStructInfo(p); }

Production:

Entrez le nom: Vedang
Entrez l'âge: 22
Entrez le salaire: 45000,00
Structure PersonInfo:
Âge: 22 ans
Nom: Vedang
Salaire: 45000

comment ouvrir les fichiers jnlp dans Windows 8

Utilisation de structures dans les fonctions - Sortie

Comme indiqué dans le programme ci-dessus, nous transmettons une structure pour qu'elle fonctionne de la même manière que les autres variables. Nous lisons les valeurs des membres de la structure à partir de l'entrée standard, puis transmettons une structure à une fonction qui affiche la structure.

Conclusion

Tout cela concernait les bases des fonctions en C ++.

Nous explorerons plus en détail les fonctions statiques en C ++ dans nos prochains tutoriels.

=> Consultez la série complète de formations GRATUITES C ++ ici.

lecture recommandée

^