Repertoire en Ligne » Développement Web » C++ » Guide du débutant pour les fonctions en C + +

3 vues | Posté par Cleménce Delong

Guide du débutant pour les fonctions en C + +

Tous les programmes C + + utiliser des fonctions. Le premier programme que vous avez écrit en C + + utilisé une fonction que vous avez déclaré que «Main». Principale est appelée par le système d’exploitation informatique. Principal est habituellement déclarée comme une fonction entière-retour, et c’est pourquoi vos programmes se terminent principal renvoie un ’0 ‘. Lorsque principal renvoie un zéro, le système d’exploitation est dit que tout va bien. S’il vous plaît rappelez-vous que principal est une fonction nécessaire dans un programme C + +, donc il doit être utilisé. Par conséquent, vos programmes doivent au moins utiliser une fonction appelée Main!

Un programme de base

Voici un exemple d’un programme de base:

Ce programme n’a évidemment rien, mais cela prouve au point que principal doit exister et renvoie généralement un zéro si l’ensemble du programme a été exécutée. Le programme le plus court qui puisse exister est la suivante:

Ce programme ne fait rien non plus, mais si vous compilez ce code source il va exécuter.

Valeur des fonctions renvoyant
Sloppy programmes écrits dans n’importe quelle langue sont mauvaises pour diverses raisons. Pour l’un, si quelqu’un analysant le code source d’un programme mal organisés veut le modifier, il peut être assez fastidieux et ennuyeux. Si vous écrivez un programme et décider de le modifier à l’avenir, mais ne peut pas comprendre comment vous l’avez écrit ou comment il fonctionne, vous êtes dedans pour quelques problèmes graves. Tout cela peut sembler évident, mais il mène dans laquelle les programmeurs briser les programmes en segments plus petits, lisible et compréhensible. Par exemple, débutants programmeurs écrivent une fonction (Principal), et d’écrire 50 lignes de code source dans Main à développer le programme. Bien sûr, le programme peut fonctionner, mais une modification future du programme peut être consommer beaucoup trop de temps, si possible à tous. En d’autres termes, ne vous une faveur; briser programmes en petits segments! Cela peut être fait en concevant et en utilisant des fonctions. Au lieu d’avoir juste une fonction de travailler pour vous dans vos programmes (Principal), utiliser plusieurs fonctions (y compris les principales). Laissez-moi vous montrer un exemple:

OK, d’abord, nous déclarons trois entiers avant le principal (a, b, c). Ensuite, nous avons tout simplement d’attribuer des valeurs à chacun d’eux et de les additionner. On imprime le résultat à l’écran et c’est tout, le programme se termine. Depuis que ce programme est si courte, ce programme est écrit très bien. Cependant, la programmation de cette façon n’est pas une bonne idée quand vos programmes commencent à devenir beaucoup plus longs et plus complexes. De plus, beaucoup de fois que vous aurez à faire un certain type de l’arithmétique avec des nombres différents à des moments différents, ce qui peut finalement conduire à code source très bâclée et la manière trop de variables dans le programme. Voici ce que je recommande; tout moment votre programme a besoin de faire tout type de calcul, la conception d’une fonction qui peut le faire pour vous. Pour vous montrer comment, je vais revoir le programme ci-dessus:

Ce programme produit les mêmes résultats, mais est beaucoup plus propre. Qu’est-ce que nous avons fait est créé une fonction appelée « Ajouter » qui peut ajouter deux nombres entiers. Cette fonction est une fonction à valeur de retour comme principal est. La première chose que nous faisons après notre tête (fstream.h) est de déclarer cette nouvelle fonction « Ajouter » {Par le chemin, la tête <fstream.h> est l’une des têtes les plus puissantes, vous pouvez utiliser en C + +}. C’est ce qu’on appelle un prototype de fonction. Il indique au compilateur qu’il ya une fonction en dehors de la principale qui peut être appelé dans le programme. Une fonction doit être déclarée avant qu’il puisse être utilisé. La plupart des programmeurs le faire dans le tout début de leurs programmes, tout comme nous avons fait ici. Ce prototype doit déclarer son type de retour (int), c’est le nom (Ajouter), et ses paramètres. Les paramètres peuvent avoir des valeurs, ou pourraient avoir aucune (comme le Main ()).

Paramètres dire au compilateur ce qui doit être envoyé à la fonction pour que cela fonctionne. Par exemple, lorsque vous mettez une pièce dans une machine à bonbons, le trimestre est le paramètre. Il doit être inséré dans la fonction (la machine) pour que cela fonctionne pour vous. Notre prototype de notre « Ajouter » fonction a deux paramètres (int, int). Par conséquent, cette fonction va travailler aussi longtemps que nous envoyons deux entiers à elle.

Nous avons ensuite déclarer trois entiers (a, b, c) avant Principal nouveau. Depuis ces trois variables entières sont déclarées en dehors des principaux, ils sont des variables globales. Cela signifie qu’ils peuvent être utilisés ou modifiés partout dans notre programme. Vous verrez l’importance de cette suite. Nous avons ensuite attribuer des valeurs à ‘a’ et ‘b’ et appelons notre « Ajouter » pour prendre la fonction de ces valeurs et les ajouter. Remarquez comment la fonction est appelée. Nous avons d’abord affecter le résultat à «c». Avant de nous appeler cette fonction, ‘c’ ne pas avoir une valeur encore. Lorsque nous appelons cette fonction de travailler pour nous, cette fonction va affecter le résultat à «c». Les deux ‘a’ et ‘b’ sont des entiers, alors cette fonction ne fonctionnera correctement. Quand une fonction est appelée, l’exécution du programme principal quitte et va à la fonction. La fonction sera alors ne c’est chose et retourner une valeur à la page principale. Cette valeur est attribuée à «c». Quand une fonction retourne au menu principal, l’exécution du programme va à l’endroit exact il s’était arrêté.

Remarquez comment on définit la fonction. C’est déclarée comme principale est. Nous devons d’abord son retour de type (int), alors c’est le nom (Ajouter), puis ses paramètres (arguments). Cependant, notez les 2 différences entre le prototype de fonction et la définition d’une fonction réelle. Le prototype se termine par un point-virgule (;), la définition de fonction ne marche pas. Dans le prototype, la spécification seul paramètre est nécessaire sont le type de valeurs nécessaires (int, int). Cependant, la définition d’une fonction réelle doit également déclarer les variables réelles qui seront utilisées dans la fonction (int a, int b). Et puis, juste comme principal, le corps de la fonction est entouré par des accolades: {}.

Concevoir et utiliser une fonction de valeur-retour nécessite les éléments suivants:

Conception de la fonction nécessaires à votre programme sur un morceau de papier.
Déclarer le prototype de la fonction au début de votre programme (avant Principal). Ce prototype doit déclarer la valeur de retour, le nom et les paramètres de la fonction.
Exemple:
Ajouter int (int a, int b)
{
retour a + b;
}
Appelez la fonction de principal en définissant une variable égal au résultat, le nom de la fonction, puis ses valeurs de paramètres.
Exemple: c = Ajouter (a, b);
Conception autant de fonctions que vous avez besoin en utilisant les quatre premières étapes. Habituellement, c’est une bonne idée de définir chaque fonction dans l’ordre, il est utilisé, l’un après l’autre.

En utilisant deux fonctions différentes

Alors vous permet désormais de concevoir un programme qui utilise deux fonctions différentes dans notre programme principal. Permet de concevoir un programme qui peut multiplier deux nombres ou 4 chiffres. Nous allons créer une fonction qui peut multiplier 2 nombres, et une autre qui peuvent se multiplier 4 chiffres. Chacune de ces fonctions auront un prototype après notre tête et auront chacun sa définition propre fonction après la Main.

Premièrement, nous définissons nos 2 prototypes de fonctions. Nous avons ensuite déclarer des variables globales 5 (a, b, c, d, e). Dans Main, nous affecter des valeurs à ‘a’, ‘b’ et ‘D’. Les valeurs pour «c» et «e» sont dérivés à partir des valeurs retournées par chaque fonction. Il ya aussi une autre chose que vous avez sans doute remarqué dans les définitions de fonction. Nous avons utilisé de nouvelles variables dans nos 2 fonctions pour calculer les résultats. Cela démontre la flexibilité des fonctions. Lorsque vous envoyez des paramètres à une fonction (comme deux nombres entiers), la fonction peut créer ses propres variables et assigner des valeurs à ces variables créées. Par exemple, notre appel à la fonction première est la suivante:

c=MultTwo(a,b);

‘A’ et ‘b’ sont envoyés à la fonction MultTwo dans cet ordre exact. La fonction MultTwo prend ces deux entiers et affecte la valeur de ‘a’ à ‘x’, et ‘b’ à ‘Y’. La fonction ne puis ses calculs et renvoie le résultat à Main. ‘C’ attrape le résultat et cela équivaut aujourd’hui que la valeur (qui est 2). Cela peut sembler déroutant au premier abord, et c’est dur à expliquer en langage clair. Peut-être un exemple concret serait utile. Lorsque les développeurs de Microsoft se réunissent pour écrire un programme très, très grande, il pourrait y avoir jusqu’à 500 différents codeurs affectés au projet. Chaque codeur aura son / sa propre devoir spécifique dans l’écriture des fonctions qui peuvent être utilisés par le programme principal. La dernière chose que Microsoft veut faire, c’est créer des variables 10millions, envoyer un fax de tous les d’eux à chaque développeur, et dire avoir du plaisir. Ce serait très stupide.

Au lieu de cela, chaque développeur sait quels sont les paramètres nécessaires à la fonction qu’ils conçoivent, travailler avec ces paramètres (arguments), et retourner une valeur à la fin. Ils peuvent créer leurs propres variables dans leurs fonctions pour aider à obtenir le résultat dont ils ont besoin, mais ces variables ne vivent à l’intérieur de la fonction et ne sera probablement pas être vu par quelqu’un d’autre. Dans notre programme ci-dessus, nous concevons une fonction que nous savons recevra 2 variables, mais leurs noms (a, b) n’ont pas d’importance pour nous. Nous avons juste besoin de leurs valeurs. Avec ces valeurs, nous pouvons calculer un nombre nécessaire et l’envoyer au principal. Obtenir l’idée?

Fonctions non avenu
Nul fonctions sont créées et utilisées comme valeur de retour des fonctions, sauf qu’ils ne retournent pas de valeur après l’exécution de la fonction. Une fonction void juste « fait quelque chose » et puis retourne. La meilleure façon de comprendre ce type de fonction est de créer un qui affiche simplement un en-tête d’un écran. Par exemple, disons que nous voulons créer une fonction qui affiche simplement à l’écran le titre du programme et de son auteur:

La définition de fonction pour une fonction Void est le même que celui d’une fonction à valeur de retour, sauf qu’il ne retourne pas une valeur à la fonction ou le programme qui l’appelle. Permet utiliser cette nouvelle fonction dans notre programme principal déjà existant.

Remarquons d’abord que la fonction d’appel à la «tête d’impression» ne renvoie pas une valeur à une variable. Pour appeler une fonction Void, vous appelez simplement son nom et les arguments, rien de plus. Alors maintenant, notre programme principal premières impressions de notre nouvel en-tête à l’écran, puis multiplie le nombre que nous utilisions auparavant. Voyez comment simples ce que c’est? Remarquez aussi le prototype de fonction est déclarée de la même comme une valeur-retour fonction est dans le tout début du programme.

Appel de fonctions Autres fonctions

Les fonctions peuvent également appeler d’autres fonctions, comme la fonction principale appelée sur nos 3 différentes fonctions ci-dessus. Vous pouvez avoir une fonction d’appels principal, qui appelle une autre fonction, qui appelle une autre fonction, etc Permet remanier le programme ci-dessus principal à le démontrer:

Compiler le programme ci-dessus. Le résultat devrait être ’20 ‘.

Maintenant, regardez comment ce programme est conçu. Main a seulement 1 ligne de code: un appel à la «tête d’impression» de fonction. Dès que cette fonction est appelée, elle attribue les mêmes valeurs à nos variables entières, les appels sur nos deux fonctions se multiplier, puis retourne au menu principal. Lorsque revient l’exécution du programme au principal, le programme se termine. S’il vous plaît noter une chose très importante: Nous pouvons utiliser et de manipuler nos 5 variables entières dans aucun de ces trois fonctions, parce qu’ils sont des variables globales. Si ces variables ont été déclarés en principal lui-même, ce programme ne fonctionnerait pas.

Pourquoi? Parce que les variables entières seraient variables locales à Main, et ne pouvait être utilisé par les principales. L’erreur que vous obtiendriez de le compilateur serait que les fonctions ne peuvent pas exécuter parce que vous tentez d’utiliser des variables entières qui n’existent pas dans ces fonctions. Va de même pour essayer d’utiliser les variables (x, y, m, n, o, p) utilisés par nos fonctions. Vous ne pouvez pas utiliser ou manipuler ces variables en principal, car ils ne sont pas définis dans Main. Ils sont des variables locales à leurs fonctions donné. Ce que je vais faire maintenant est de marcher dans cette exécution des programmes, étape par étape et de démontrer comment l’ensemble des variables utilisées par nos fonctions (y compris les principales) sont traités par notre programme. Je vais modifier la portée des variables utilisées par les deux fonctions en multipliant des fins de démonstration.

Voici le nouveau programme:

La première chose que nous faisons après notre tête est de déclarer nos prototypes de fonction 3. Nous entrons alors principal, à quel point ce programme n’a pas encore les variables déclarées. Dès que nous entrons dans Main, un appel de fonction est faite pour « tête d’impression» et l’exécution des feuilles principales. «Tête d’impression» déclare 5 entiers nouvelles et affecte des valeurs à ‘a’ et ‘b’.

Le « MultTwo » est alors appelé. Les valeurs de ‘a’ et ‘b’ sont envoyés à la « MultTwo » fonction et sont copiés dans deux variables nouvellement créé «x» et «y». Depuis «a» est égale à 1, ‘x’ aujourd’hui est aussi égale à 1. Depuis «b» est égal à 2, ‘y’ aujourd’hui est aussi égale à 2. « MultTwo multiplie ‘x’ et ‘y’ et retourne une valeur de 2 à la« tête d’impression »de fonction. Suivant« d »est attribué une valeur et tous les 4 variables, LOCAL pour » tête d’impression », sont envoyés au« MultFour « . Cette fonction reçoit les valeurs de (1, 2, 2, 5) et des copies de ces valeurs dans (m, n, o, p). Donc m = 1, n = 2, o = 2 et p = 5. Ces valeurs sont tous multipliés et le résultat est retourné à « tête d’impression». Cette fonction affiche à l’écran la valeur de «e», à laquelle la fonction termine son appel, et retourne l’exécution Retour au menu principal de simplement la fin!

Passage par référence
Une fonction peut reçoit également les arguments par référence plutôt que par valeur, comme nous l’avons fait jusqu’ici. Dans la « mult » fonctions ci-dessus, 2 ou 4 valeurs ont été envoyés à la fonction appropriée de la valeur. En d’autres termes, lorsque nous avons fait un appel de fonction, les valeurs des variables (tels que ‘a’ et ‘b’) ont été envoyés à la fonction comme arguments et la fonction utilisé ces valeurs dans son corps pour calculer ce qu’il fallait. Cependant, il ya une autre façon d’obtenir les mêmes résultats. Au lieu d’envoyer réellement les valeurs de ces variables, on peut simplement envoyer les adresses mémoire de ces variables. Vous voyez, quand vous déclarez une variable dans un programme, le compilateur réserve un espace dans la mémoire pour cette variable. Vous n’avez jamais décider où dans la mémoire des ordinateurs de cette variable sera stockée, l’ordinateur est-ce que pour vous. Mais vous pouvez effectivement trouver l’adresse exacte de l’endroit où il est stocké, et vous pouvez manipuler ce qui est stocké là manuellement. Par exemple, voici un petit programme qui utilise uniquement une fonction pour ajouter deux nombres ensemble:

J’ai décidé d’utiliser une fonction void ici juste pour vous montrer que vous pouvez faire des calculs avec des fonctions Interdit aussi facilement que la valeur des fonctions renvoyant. Le résultat affiché à l’écran à la fin des programmes sera ’3 ‘. S’il vous plaît noter également que ‘z’ la variable est locale à la fonction « Ajouter », et ne peuvent être utilisés ou manipulés par cette fonction.

Maintenant passons à passer des arguments à cette « Ajouter » fonction par référence cette fois-ci pour obtenir le même résultat. La seule modification que nous devons faire est d’ajouter une esperluette (&) entre le type d’argument et de la variable utilisée dans la fonction:

Cette nouvelle fonction reçoit l’adresse mémoire de ‘a’ et ‘b’, et non leurs valeurs réelles. Le résultat sera le même cependant.

L’utilisation en passant par les arguments de référence à des fonctions ajoute beaucoup de souplesse à vos programmes, mais vous devez être prudent! Si vous changez une valeur stockée dans une adresse mémoire des variables, les choses peuvent se détraquer si vous n’avez pas l’intention. Vous êtes réellement changer ce qui est dans l’adresse mémoire de la variable. Donc, si vous changez sa valeur en manipulant son adresse, la valeur réelle (ou entier) va changer aussi. Par exemple, si la fonction ne présente:

En principal, les valeurs de ces deux entiers sont ’1 ‘et ’2′ en conséquence. Lorsque cette fonction reçoit les adresses mémoire de ces deux variables, il manipule ces adresses mémoire et retourne au menu principal. En principal, les valeurs de ‘a’ et ‘b’ sont maintenant ’5 ‘et ’5′ en conséquence, pas de ’1 ‘et ’2′ comme avant. En d’autres termes, vous avez atteint profondément à l’intérieur du PC, a trouvé les adresses des deux variables, les a envoyés à une fonction, la fonction de manipuler directement l’adresse, et les valeurs de ces deux variables sont modifiées pour de bon! Un prototype de cette fonction doit également inclure la (&), parce que le compilateur doit savoir que vous l’intention de passer des références à elle:

Nettoyage de votre code
Lorsque vous écrivez des programmes, vous voulez vous assurer que votre code source est lisible et clairement compréhensibles pour vous, et quiconque a l’intention de le lire. Cela peut être fait facilement avec pré-conditions et post-conditions. Pré-conditions décrivent les arguments, le cas échéant, la fonction reçoit. Post-conditions en détail ce que la fonction va faire avant qu’il ne retourne à la fonction qui l’appelle. Dans notre exemple la fonction précédente, permet de faire ceci:

Maintenant cette fonction est plus lisible pour tout le monde.

Conclusion

La pratique rend parfait, donc la pratique la conception de vos propres fonctions et les utiliser. Pour toute fonction que vous créez, vous devez vous rappeler d’effectuer les opérations suivantes: