Function declaration

Comme mentionné dans Declarations , le déclarateur peut être suivi d'une requires clause , qui déclare les constraints associées pour la fonction, qui doivent être satisfaites afin que la fonction soit sélectionnée par la overload resolution . (exemple : void f1 ( int a ) requires true ; ) Notez que la contrainte associée fait partie de la signature de la fonction, mais ne fait pas partie du type de fonction.

L'utilisation d'un type d'objet qualifié volatile comme type de paramètre ou type de retour est dépréciée.

Comme pour toute déclaration, les attributs qui apparaissent avant la déclaration et ceux qui apparaissent immédiatement après l'identifiant dans le déclarateur s'appliquent tous deux à l'entité déclarée ou définie (dans ce cas, à la fonction) :

[[noreturn]] void f [[noreturn]] (); // OK: both attributes apply to the function f

Cependant, les attributs qui apparaissent après le déclarateur (dans la syntaxe ci-dessus) s'appliquent au type de la fonction, et non à la fonction elle-même :

void f() [[noreturn]]; // Error: this attribute has no effect on the function itself

Déduction du type de retour

Si la decl-specifier-seq de la déclaration de fonction contient le mot-clé auto , le type de retour trailing peut être omis, et sera déduit par le compilateur à partir du type de l'opérande utilisé dans l'instruction non-discarded return . Si le type de retour n'utilise pas decltype ( auto ) , la déduction suit les règles de template argument deduction :

int x = 1;
auto f() { return x; }        // type de retour est int
const auto& f() { return x; } // type de retour est const int&

Si le type de retour est decltype ( auto ) , le type de retour correspond à ce qui serait obtenu si l'opérande utilisé dans l'instruction return était encapsulé dans decltype :

int x = 1;
decltype(auto) f() { return x; }  // type de retour est int, identique à decltype(x)
decltype(auto) f() { return(x); } // type de retour est int&, identique à decltype((x))

(note: “ const decltype ( auto ) & ” est une erreur, decltype ( auto ) doit être utilisé seul)

S'il y a plusieurs instructions de retour, elles doivent toutes déduire le même type :

auto f(bool val)
{
    if (val) return 123; // déduit le type de retour int
    else return 3.14f;   // Erreur : déduit le type de retour float
}

S'il n'y a pas d'instruction return ou si l'opérande de l'instruction return est une expression void (y compris les instructions return sans opérande), le type de retour déclaré doit être soit decltype ( auto ) , auquel cas le type de retour déduit est void , ou (éventuellement qualifié cv) auto , auquel cas le type de retour déduit est alors (identique qualifié cv) void :

auto f() {}              // retourne void
auto g() { return f(); } // retourne void
auto* x() {}             // Erreur : impossible de déduire auto* à partir de void

Une fois qu'une instruction return a été rencontrée dans une fonction, le type de retour déduit à partir de cette instruction peut être utilisé dans le reste de la fonction, y compris dans d'autres instructions return :

auto sum(int i)
{
    if (i == 1)
        return i;              // le type de retour de sum est int
    else
        return sum(i - 1) + i; // OK : le type de retour de sum est déjà connu
}

Si l'instruction return utilise une liste d'initialisation entre accolades , la déduction n'est pas autorisée :

auto func() { return {1, 2, 3}; } // Erreur

Fonctions virtuelles et coroutines (depuis C++20) ne peuvent pas utiliser la déduction du type de retour :

struct F
{
    virtual auto f() { return 2; } // Erreur
};

Modèles de fonction autres que les fonctions de conversion définies par l'utilisateur peuvent utiliser la déduction du type de retour. La déduction a lieu lors de l'instanciation même si l'expression dans l'instruction return n'est pas dépendante . Cette instanciation n'est pas dans un contexte immédiat pour les besoins de SFINAE .

template<class T>
auto f(T t) { return t; }
typedef decltype(f(1)) fint_t;    // instancie f<int> pour déduire le type de retour
template<class T>
auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // instancie les deux f pour déterminer les types de retour,
                                  // choisit la seconde surcharge de template

Les redéclarations ou spécialisations de fonctions ou de modèles de fonction qui utilisent la déduction du type de retour doivent utiliser les mêmes espaces réservés pour le type de retour :

auto f(int num) { return num; }
// int f(int num);            // Erreur : pas de type de retour substitut
// decltype(auto) f(int num); // Erreur : substitut différent
template<typename T>
auto g(T t) { return t; }
template auto g(int);     // OK : le type de retour est int
// template char g(char); // Erreur : pas une spécialisation du template principal g

De même, les redéclarations ou spécialisations de fonctions ou de modèles de fonction qui n'utilisent pas la déduction de type de retour ne doivent pas utiliser un espace réservé :

int f(int num);
// auto f(int num) { return num; } // Erreur : pas une redéclaration de f
template<typename T>
T g(T t) { return t; }
template int g(int);      // OK : spécialisation de T en int
// template auto g(char); // Erreur : pas une spécialisation du template primaire g

Les déclarations d'instanciation explicite n'instancient pas elles-mêmes les modèles de fonction qui utilisent la déduction de type de retour :

template<typename T>
auto f(T t) { return t; }
extern template auto f(int); // n'instancie pas f<int>
int (*p)(int) = f; // instancie f<int> pour déterminer son type de retour,
                   // mais une définition d'instanciation explicite
                   // est toujours requise quelque part dans le programme

Si l'un des paramètres de fonction utilise un espace réservé (soit auto ou un type concept ), la déclaration de fonction est plutôt une déclaration de modèle de fonction abrégé :

void f1(auto);    // same as template<class T> void f1(T)
void f2(C1 auto); // same as template<C1 T> void f2(T), if C1 is a concept

Une déclaration de paramètre avec le spécificateur this (syntaxe ( 2 ) / ( 5 ) ) déclare un paramètre objet explicite .

Un paramètre objet explicite ne peut pas être un pack de paramètres de fonction , et il ne peut apparaître que comme premier paramètre de la liste de paramètres dans les déclarations suivantes :

• une déclaration de fonction membre ou de modèle de fonction membre
• une instanciation explicite ou spécialisation explicite d'une fonction membre template
• une déclaration de lambda

Une fonction membre avec un paramètre objet explicite a les restrictions suivantes :

• La fonction n'est pas static .
• La fonction n'est pas virtual .
• Le déclarateur de la fonction ne contient pas cv et ref .

struct C
{
    void f(this C& self);     // OK
    template<typename Self>
    void g(this Self&& self); // also OK for templates
    void p(this C) const;     // Error: “const” not allowed here
    static void q(this C);    // Error: “static” not allowed here
    void r(int, this C);      // Error: an explicit object parameter
                              //        can only be the first parameter
};
// void func(this C& self);   // Error: non-member functions cannot have
                              //        an explicit object parameter

• Si la spécification d'exception est non-lancante , le type de la fonction déclarée est
  « liste-de-déclarateurs-dérivés noexcept fonction de
  liste-de-types-de-paramètres cv  (optionnel) ref   (optionnel) retournant T ».

Dans la syntaxe (2) , en supposant noptr-declarator comme une déclaration autonome, étant donné le type du qualified-id ou unqualified-id dans noptr-declarator comme « derived-declarator-type-list T » ( T doit être auto dans ce cas) :

• Si la spécification d'exception est non-lancante , le type de la fonction déclarée est
  « derived-declarator-type-list noexcept fonction de
  parameter-type-list cv  (optionnel) ref   (optionnel) retournant trailing  ».

• Le (jusqu'à C++17) Sinon, le (depuis C++17) type de la fonction déclarée est
  « derived-declarator-type-list fonction de
  parameter-type-list cv  (optionnel) ref   (optionnel) retournant trailing  ».

attr , s'il est présent, s'applique au type de fonction.

• ref

• clause requires finale

• Si la fonction est une fonction friend non-template avec une clause requires finale, sa signature contient la classe englobante au lieu de l'espace de noms englobant. La signature contient également la clause requires finale.

Si une définition de fonction contient un virt-specs , elle doit définir une fonction membre .

Si une définition de fonction contient une requires-clause , elle doit définir une fonction template .

Fonctions par défaut

Si la définition de la fonction est de syntaxe ( 3 ) , la fonction est définie comme explicitement définie par défaut .

Une fonction explicitement définie par défaut doit être une fonction membre spéciale ou une fonction d'opérateur de comparaison (depuis C++20) , et elle ne doit pas avoir d' argument par défaut .

Une fonction membre spéciale explicitement définie par défaut F1 est autorisée à différer de la fonction membre spéciale correspondante F2 qui aurait été implicitement déclarée, comme suit :

• F1 et F2 peuvent avoir des spécifications ref et/ou except différentes.
• Si F2 possède un paramètre non-objet de type const C & , le paramètre non-objet correspondant de F1 peut être de type C& .

Si le type de F1 diffère du type de F2 d'une manière autre que celle autorisée par les règles précédentes, alors :

• Si F1 est un opérateur d'affectation, et que le type de retour de F1 diffère du type de retour de F2 ou que le type de paramètre non-objet de F1 n'est pas une référence, le programme est mal formé.
• Sinon, si F1 est explicitement déclaré par défaut dans sa première déclaration, il est défini comme supprimé.
• Sinon, le programme est mal formé.

Une fonction explicitement définie par défaut lors de sa première déclaration est implicitement inline , et est implicitement constexpr si elle peut être une fonction constexpr .

struct S
{
    S(int a = 0) = default;             // erreur : argument par défaut
    void operator=(const S&) = default; // erreur : type de retour non correspondant
    ~S() noexcept(false) = default;     // OK, spécification d'exception différente
private:
    int i;
    S(S&);          // OK, constructeur de copie privé
};
S::S(S&) = default; // OK, définit le constructeur de copie

Les fonctions explicitement définies par défaut et les fonctions implicitement déclarées sont collectivement appelées fonctions par défaut . Leurs définitions réelles seront fournies implicitement, consultez leurs pages correspondantes pour plus de détails.

Fonctions supprimées

Si la définition de la fonction est de syntaxe ( 4 ) ou ( 5 ) (depuis C++26) , la fonction est définie comme explicitement supprimée .

Toute utilisation d'une fonction supprimée est mal formée (le programme ne compilera pas). Cela inclut les appels, explicites (avec un opérateur d'appel de fonction) et implicites (un appel à un opérateur surchargé supprimé, une fonction membre spéciale, une fonction d'allocation, etc.), la construction d'un pointeur ou d'un pointeur-vers-membre vers une fonction supprimée, et même l'utilisation d'une fonction supprimée dans une expression qui n'est pas potentiellement évaluée .

Une fonction membre virtuelle non pure peut être définie comme supprimée, même si elle est implicitement odr-used . Une fonction supprimée ne peut être remplacée que par des fonctions supprimées, et une fonction non supprimée ne peut être remplacée que par des fonctions non supprimées.

Si la fonction est surchargée, la résolution de surcharge a lieu en premier, et le programme est seulement mal-formé si la fonction supprimée a été sélectionnée :

struct T
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete("new[] is deleted"); // depuis C++26
};
T* p = new T;    // Erreur : tente d'appeler T::operator new supprimé
T* p = new T[5]; // Erreur : tente d'appeler T::operator new[] supprimé,
                 //        émet un message de diagnostic "new[] is deleted"

La définition supprimée d'une fonction doit être la première déclaration dans une unité de traduction : une fonction précédemment déclarée ne peut pas être redéclarée comme supprimée :

struct T { T(); };
T::T() = delete; // Erreur : doit être supprimé lors de la première déclaration

Fonctions fournies par l'utilisateur

Une fonction est fournie par l'utilisateur si elle est déclarée par l'utilisateur et non explicitement définie par défaut ou supprimée lors de sa première déclaration. Une fonction explicitement définie par défaut fournie par l'utilisateur (c'est-à-dire explicitement définie par défaut après sa première déclaration) est définie au point où elle est explicitement définie par défaut ; si une telle fonction est implicitement définie comme supprimée, le programme est non valide. Déclarer une fonction comme définie par défaut après sa première déclaration peut offrir une exécution efficace et une définition concise tout en permettant une interface binaire stable pour une base de code en évolution.

// Toutes les fonctions membres spéciales de « trivial » sont
// définies par défaut sur leurs premières déclarations respectivement,
// elles ne sont pas fournies par l'utilisateur
struct trivial
{
    trivial() = default;
    trivial(const trivial&) = default;
    trivial(trivial&&) = default;
    trivial& operator=(const trivial&) = default;
    trivial& operator=(trivial&&) = default;
    ~trivial() = default;
};
struct nontrivial
{
    nontrivial(); // première déclaration
};
// non définie par défaut sur la première déclaration,
// elle est fournie par l'utilisateur et est définie ici
nontrivial::nontrivial() = default;

Résolution d'Ambiguïté

En cas d'ambiguïté entre un corps de fonction et un initialiseur commençant par { ou = (depuis C++26) , l'ambiguïté est résolue en vérifiant le type de l' identifiant du déclarateur du noptr-declarator :

• Si le type est un type de fonction, la séquence de jetons ambigus est traitée comme un corps de fonction.
• Sinon, la séquence de jetons ambigus est traitée comme un initialiseur.

using T = void(); // type de fonction
using U = int;    // type non-fonction
T a{}; // définit une fonction ne faisant rien
U b{}; // initialise par valeur un objet int
T c = delete("hello"); // définit une fonction comme supprimée
U d = delete("hello"); // initialise par copie un objet int avec
                       // le résultat d'une expression delete (mal formé)

__func__

Dans le corps de la fonction, la variable prédéfinie locale à la fonction __func__ est définie comme si par

static const char __func__[] = "nom-de-fonction";

Cette variable a une portée de bloc et une durée de stockage statique :

struct S
{
    S(): s(__func__) {} // OK : la liste d'initialisation fait partie du corps de la fonction
    const char* s;
};
void f(const char* s = __func__); // Erreur : la liste de paramètres fait partie du déclarateur

#include <iostream>
void Foo() { std::cout << __func__ << ' '; }
struct Bar
{
    Bar() { std::cout << __func__ << ' '; }
    ~Bar() { std::cout << __func__ << ' '; }
    struct Pub { Pub() { std::cout << __func__ << ' '; } };
};
int main()
{
    Foo();
    Bar bar;
    Bar::Pub pub;
}

Foo Bar Pub ~Bar

Spécificateurs de contrat de fonction

Les déclarations de fonctions et les expressions lambda peuvent contenir une séquence de spécificateurs de contrat de fonction  , chaque spécificateur a la syntaxe suivante :

L'assertion de précondition et l'assertion de postcondition sont collectivement appelées assertion de contrat de fonction  .

Une assertion de contrat de fonction est une assertion de contrat associée à une fonction. Le prédicat d'une assertion de contrat de fonction est son prédicat converti contextuellement en bool .

Les fonctions suivantes ne peuvent pas être déclarées avec des spécificateurs de contrat de fonction :

• fonctions virtuelles
• fonctions supprimées
• fonction par défaut sur leurs premières déclarations

Assertions de précondition

Une assertion de précondition est associée à l'entrée d'une fonction :

int divide(int dividend, int divisor) pre(divisor != 0)
{
    return dividend / divisor;
}
double square_root(double num) pre(num >= 0)
{
    return std::sqrt(num);
}

` et contient des termes spécifiques au C++ qui doivent être préservés selon vos instructions. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Assertions de postcondition

Une assertion de postcondition est associée à la sortie normale d'une fonction.

Si une assertion de postcondition possède un identifiant , le spécificateur de contrat de fonction introduit identifiant comme nom d'une liaison de résultat de la fonction associée. Une liaison de résultat désigne l'objet ou la référence retournée par l'invocation de cette fonction. Le type d'une liaison de résultat est le type de retour de sa fonction associée.

int absolute_value(int num) post(r : r >= 0)
{
    return std::abs(num);
}
double sine(double num) post(r : r >= -1.0 && r <= 1.0)
{
    if (std::isnan(num) || std::isinf(num))
        // la sortie via une exception ne cause jamais de violation de contrat
        throw std::invalid_argument("Argument invalide");
    return std::sin(num);
}

Si une assertion de postcondition possède un identifiant , et que le type de retour de la fonction associée est (éventuellement qualifié cv) void , le programme est mal formé :

void f() post(r : r > 0); // Erreur : aucune valeur ne peut être liée à « r »

Lorsque le type de retour déclaré d'une fonction non template contient un type substitut , une assertion de postcondition avec un identifiant  ne peut apparaître que dans une définition de fonction :

auto g(auto&) post(r : r >= 0); // OK, « g » est un template
auto h() post(r : r >= 0);      // Erreur : impossible de nommer la valeur de retour
auto k() post(r : r >= 0)       // OK, « k » est une définition
{
    return 0;
}

Cohérence des contrats

Une redéclaration D d'une fonction ou d'un modèle de fonction func doit avoir soit aucune spécification de contrat soit les mêmes spécifications de contrat que toute première déclaration F accessible depuis D . Si D et F sont dans différentes unités de traduction, un diagnostic n'est requis que si D est attachée à un module nommé.

Si une déclaration F1 est une première déclaration de func dans une unité de traduction et qu'une déclaration F2 est une première déclaration de func dans une autre unité de traduction, F1 et F2 doivent spécifier les mêmes contract-specs , aucun diagnostic requis.

Deux contract-specs sont identiques s'ils consistent en les mêmes spécificateurs de contrat de fonction dans le même ordre.

Un spécificateur de contrat de fonction C1 sur une déclaration de fonction D1 est identique à un spécificateur de contrat de fonction C2 sur une déclaration de fonction D2 si toutes les conditions suivantes sont satisfaites :

• Les prédicats de C1 et C2 satisferaient la règle de définition unique s'ils étaient placés dans des définitions de fonction sur les déclarations D1 et D2 (si D1 et D2 sont dans différentes unités de traduction, les entités correspondantes définies dans chaque prédicat se comportent comme s'il y avait une seule entité avec une seule définition), respectivement, à l'exception des renommages suivants :
  • Le renommage des paramètres de la fonction déclarée.
  • Le renommage des paramètres de template d'un template englobant la fonction déclarée.
  • Le renommage de la liaison de résultat (le cas échéant).
• Les deux C1 et C2 ont un identifiant ou aucun n'en a.

Si cette condition n'est pas satisfaite uniquement en raison de la comparaison de deux expressions lambda qui sont contenues dans les prédicats , aucun diagnostic n'est requis.

bool b1, b2;
void f() pre (b1) pre([]{ return b2; }());
void f(); // OK, spécificateurs de contrat de fonction omis
void f() pre (b1) pre([]{ return b2; }()); // Erreur : les fermetures ont des types différents
void f() pre (b1); // Erreur : les spécificateurs de contrat de fonction sont différents
int g() post(r : b1);
int g() post(b1); // Erreur : aucune liaison de résultat
namespace N
{
    void h() pre (b1);
    bool b1;
    void h() pre (b1); // Erreur : les spécificateurs de contrat de fonction diffèrent
                       //        selon la règle de définition unique
}