Functions

Les fonctions sont des entités C++ qui associent une séquence de instructions (un corps de fonction ) à un nom et une liste de zéro ou plusieurs paramètres de fonction .

// nom de la fonction : "isodd"
// la liste des paramètres a un paramètre, avec le nom "n" et le type int
// le type de retour est bool
bool isodd(int n)
{                 // le corps de la fonction commence
    return n % 2;
}                 // le corps de la fonction se termine

Lorsqu'une fonction est invoquée, par exemple dans une expression d'appel de fonction , les paramètres sont initialisés à partir des arguments (soit fournis à l'endroit de l'appel soit par défaut ) et les instructions dans le corps de la fonction sont exécutées. Si la liste de paramètres se termine par ... , des arguments supplémentaires peuvent être fournis à la fonction, une telle fonction est appelée fonction variadique .

int main()
{
    for (int arg : {-3, -2, -1, 0, 1, 2, 3})
        std::cout << isodd(arg) << ' '; // isodd appelé 7 fois, chaque
                                        // fois n est initialisé par copie à partir de arg
}

Unqualified les noms de fonctions dans les expressions d'appel de fonction sont recherchés avec un ensemble supplémentaire de règles appelé "argument-dependent lookup" (ADL) .

Une fonction peut se terminer en retournant ou en lançant une exception .

Une déclaration de fonction peut apparaître dans n'importe quelle portée, mais une définition de fonction ne peut apparaître qu'au niveau de l'espace de noms ou, pour les fonctions membres et amies , au niveau de la classe. Une fonction déclarée dans un corps de classe sans spécificateur friend est une fonction membre de classe. Ces fonctions possèdent de nombreuses propriétés supplémentaires, voir fonctions membres pour plus de détails.

Les fonctions ne sont pas des objets : il n'existe pas de tableaux de fonctions et les fonctions ne peuvent pas être passées par valeur ou renvoyées par d'autres fonctions. Les pointeurs et références vers des fonctions (sauf pour la fonction main et la plupart des fonctions de la bibliothèque standard (depuis C++20) ) sont autorisés, et peuvent être utilisés là où ces fonctions elles-mêmes ne le peuvent pas. C'est pourquoi nous disons que ces fonctions sont "adressables".

Chaque fonction a un type, qui se compose du type de retour de la fonction, des types de tous les paramètres (après les transformations tableau-vers-pointeur et fonction-vers-pointeur, voir liste des paramètres ) , que la fonction soit noexcept ou non (depuis C++17) , et, pour les fonctions membres non statiques, la qualification cv et la qualification de référence (depuis C++11) . Les types de fonctions ont également un lien de langage . Il n'existe pas de types de fonctions qualifiés cv (à ne pas confondre avec les types des fonctions qualifiées cv telles que int f ( ) const ; ou les fonctions retournant des types qualifiés cv , telles que std:: string const f ( ) ; ). Toute qualification cv est ignorée si elle est ajoutée à un alias d'un type de fonction.

Plusieurs fonctions dans la même portée peuvent avoir le même nom, à condition que leurs listes de paramètres et, pour les fonctions membres non statiques, leurs qualifications cv /ref (depuis C++11) soient différentes. Ceci est connu sous le nom de surcharge de fonction . Les déclarations de fonctions qui ne diffèrent que par le type de retour et la spécification noexcept (depuis C++17) ne peuvent pas être surchargées. L' adresse d'une fonction surchargée est déterminée différemment.

Objets fonction

Outre les lvalues de fonction, l'expression d'appel de fonction prend en charge les pointeurs vers des fonctions, et toute valeur de type classe qui surcharge l'opérateur d'appel de fonction ou est convertible en pointeur de fonction (y compris les expressions lambda ) (depuis C++11) . Ensemble, ces types sont connus sous le nom de FunctionObject s , et ils sont utilisés de manière ubiquitaire dans la bibliothèque standard C++, voir par exemple les utilisations de BinaryPredicate et Compare .

La bibliothèque standard fournit également un certain nombre de modèles d'objets fonction prédéfinis ainsi que les méthodes pour en composer de nouveaux (incluant std::less , std::mem_fn , std::bind , std::function (depuis C++11) , std::not_fn (depuis C++17) , std::bind_front (depuis C++20) , std::bind_back , std::move_only_function (depuis C++23) , std::copyable_function , et std::function_ref (depuis C++26) ).