C++ Fonction

Définir une fonction

La forme générale d'une définition de fonction en C++ est la suivante :

En C++, une fonction se compose d'un en-tête de fonction et d'un corps de fonction. Voici une liste de tous les composants d'une fonction :

• Type de retour :Une fonction peut renvoyer une valeur.return_typeEst le type de données de la valeur renvoyée par la fonction. Certaines fonctions effectuent les opérations requises sans renvoyer de valeur ; dans ce cas, return_type est le mot-clévoid。
• Nom de la fonction :C'est le nom réel de la fonction. Le nom de la fonction et la liste de paramètres constituent ensemble la signature de la fonction.
• Paramètres :Les paramètres sont comme des espaces réservés. Lorsqu'une fonction est appelée, vous passez une valeur au paramètre ; cette valeur est appelée argument réel. La liste de paramètres comprend les types, l'ordre et le nombre des paramètres de la fonction. Les paramètres sont facultatifs, c'est-à-dire qu'une fonction peut ne contenir aucun paramètre.
• Corps de la fonction :Le corps de la fonction contient un ensemble d'instructions qui définissent la tâche que la fonction effectue.

Exemple

Ce qui suit estmax()Le code source de la fonction. Cette fonction a deux paramètres, num1 et num2, et renvoie le plus grand des deux nombres :

Déclaration de fonction

Déclarationde fonctionIndique au compilateur le nom de la fonction et comment appeler la fonction. Le corps réel de la fonction peut être défini séparément.

Une déclaration de fonction se compose des parties suivantes :

return_type function_name( parameter list );

Pour la fonction max() définie ci-dessus, la déclaration de fonction est la suivante :

int max(int num1, int num2);

Dans une déclaration de fonction, les noms des paramètres n'ont pas d'importance ; seuls les types des paramètres sont requis. Par conséquent, ce qui suit est également une déclaration valide :

int max(int, int);

Lorsque vous définissez une fonction dans un fichier source et l'appelez dans un autre fichier, une déclaration de fonction est nécessaire. Dans ce cas, vous devez déclarer la fonction en haut du fichier qui appelle la fonction.

Appeler une fonction

Lorsque vous créez une fonction C++, vous définissez ce que fait la fonction, puis vous appelez la fonction pour accomplir la tâche définie.

Lorsqu’un programme appelle une fonction, le contrôle du programme est transféré à la fonction appelée. La fonction appelée exécute la tâche définie. Lorsque l’instruction return de la fonction est exécutée, ou lorsque l’accolade fermante de la fonction est atteinte, le contrôle du programme est renvoyé au programme appelant.

Lors de l’appel d’une fonction, passez les arguments requis. Si la fonction renvoie une valeur, vous pouvez stocker la valeur de retour. Par exemple :

Placez la fonction max() et la fonction main() ensemble, puis compilez le code source. Lorsque le fichier exécutable final est exécuté, il produit les résultats suivants :

Max value is : 200

Paramètres de fonction

Si une fonction doit utiliser des paramètres, elle doit déclarer des variables qui acceptent les valeurs des paramètres. Ces variables sont appelées les paramètres formels de la fonction.Paramètres formels。

Les paramètres formels sont comme les autres variables locales à l'intérieur de la fonction ; ils sont créés à l'entrée de la fonction et détruits à sa sortie.

Lors de l'appel d'une fonction, il existe trois façons de passer des arguments à la fonction :

Par défaut, C++ utilisel'appel par valeurpour passer des paramètres. En général, cela signifie que le code à l'intérieur de la fonction ne peut pas modifier les arguments utilisés pour appeler la fonction. Dans l'exemple mentionné précédemment, la même méthode a été utilisée lors de l'appel de la fonction max().

Valeurs par défaut des paramètres

Lorsque vous définissez une fonction, vous pouvez spécifier une valeur par défaut pour chacun des paramètres qui suivent dans la liste des paramètres. Lors de l'appel de la fonction, si l'argument réel est laissé vide, cette valeur par défaut est utilisée.

Cela se fait en utilisant l'opérateur d'affectation dans la définition de la fonction pour affecter des valeurs aux paramètres. Lorsque la fonction est appelée, si aucune valeur n'est transmise pour un paramètre, la valeur par défaut est utilisée ; si une valeur est spécifiée, la valeur par défaut est ignorée et la valeur transmise est utilisée. Voir l'exemple suivant :

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Total value is :300
Total value is :120

Fonctions et expressions lambda

C++11 prend en charge les fonctions anonymes, appelées fonctions Lambda (également appelées expressions Lambda).

Les expressions Lambda traitent les fonctions comme des objets. Les expressions Lambda peuvent être utilisées comme des objets, par exemple, elles peuvent être assignées à des variables et passées comme arguments, et elles peuvent également être évaluées comme des fonctions.

Les expressions Lambda sont essentiellement très similaires aux déclarations de fonctions. La forme spécifique d'une expression Lambda est la suivante :

[capture](parameters)->return-type{body}

Par exemple :

[](int x, int y){ return x < y ; }

S'il n'y a pas de valeur de retour, cela peut s'exprimer comme suit :

[capture](parameters){body}

Par exemple :

[]{ ++global_x; } 

Dans un exemple plus complexe, le type de retour peut être spécifié explicitement comme suit :

[](int x, int y) -> int { int z = x + y; return z + x; }

Dans cet exemple, un paramètre temporaire z est créé pour stocker le résultat intermédiaire. Comme pour une fonction ordinaire, la valeur de z n'est pas conservée jusqu'au prochain appel de cette fonction sans nom.

Si une fonction Lambda ne renvoie aucune valeur (par exemple, void), son type de retour peut être complètement omis.

Les variables de la portée actuelle sont accessibles à l'intérieur d'une expression Lambda ; c'est le comportement de fermeture des expressions Lambda. Contrairement aux fermetures JavaScript, le passage de variables en C++ distingue le passage par valeur et le passage par référence. Cela peut être spécifié via le [] précédent :

[]      // 沒有定义任何变量。使用未定义变量会引发错误。
[x, &y] // x以传值方式传入（默认），y以引用方式传入。
[&]     // 任何被使用到的外部变量都隐式地以引用方式加以引用。
[=]     // 任何被使用到的外部变量都隐式地以传值方式加以引用。
[&, x]  // x显式地以传值方式加以引用。其余变量以引用方式加以引用。
[=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。

Une autre chose à noter. Pour les formes [=] ou [&], l'expression Lambda peut utiliser directement le pointeur this. Cependant, pour la forme [], si vous souhaitez utiliser le pointeur this, il doit être passé explicitement :

[this]() { this->someFunc(); }();