Function declaration

Wie in Deklarationen erwähnt, kann der Deklarator von einer requires -Klausel gefolgt werden, die die zugehörigen Constraints für die Funktion deklariert. Diese müssen erfüllt sein, damit die Funktion durch Overload Resolution ausgewählt wird. (Beispiel: void f1 ( int a ) requires true ; ) Beachten Sie, dass das zugehörige Constraint Teil der Funktionssignatur, aber nicht Teil des Funktionstyps ist.

Die Verwendung eines volatile-qualifizierten Objekttyps als Parametertyp oder Rückgabetyp ist veraltet.

Wie bei jeder Deklaration gelten sowohl Attribute, die vor der Deklaration erscheinen, als auch Attribute, die unmittelbar nach dem Bezeichner innerhalb des Deklarators erscheinen, für die deklarierte oder definierte Entität (in diesem Fall für die Funktion):

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

Allerdings gelten die Attribute, die nach dem Deklarator erscheinen (in der obigen Syntax), für den Typ der Funktion, nicht für die Funktion selbst:

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

Rückgabetyp-Deduktion

Wenn die Deklarator-Spezifizierer-Sequenz der Funktionsdeklaration das Schlüsselwort auto enthält, kann der nachgestellte Rückgabetyp weggelassen werden und wird vom Compiler aus dem Typ des Operanden im nicht-verworfenen return -Statement abgeleitet. Wenn der Rückgabetyp nicht decltype ( auto ) verwendet, folgt die Ableitung den Regeln der Template-Argument-Ableitung :

int x = 1;
auto f() { return x; }        // Rückgabetyp ist int
const auto& f() { return x; } // Rückgabetyp ist const int&

Wenn der Rückgabetyp decltype ( auto ) ist, entspricht der Rückgabetyp dem, was erhalten würde, wenn der Operand in der return-Anweisung in decltype eingeschlossen wäre:

int x = 1;
decltype(auto) f() { return x; }  // Rückgabetyp ist int, gleich wie decltype(x)
decltype(auto) f() { return(x); } // Rückgabetyp ist int&, gleich wie decltype((x))

(Hinweis: „ const decltype ( auto ) & “ ist ein Fehler, decltype ( auto ) muss alleinstehend verwendet werden)

Wenn es mehrere return-Anweisungen gibt, müssen alle auf denselben Typ deduzieren:

auto f(bool val)
{
    if (val) return 123; // leitet Rückgabetyp int ab
    else return 3.14f;   // Fehler: leitet Rückgabetyp float ab
}

Wenn es keine return-Anweisung gibt oder wenn der Operand der return-Anweisung ein void-Ausdruck ist (einschließlich return-Anweisungen ohne Operand), muss der deklarierte Rückgabetyp entweder decltype ( auto ) sein, wobei der abgeleitete Rückgabetyp void ist, oder (möglicherweise cv-qualifiziertes) auto , wobei der abgeleitete Rückgabetyp dann (identisch cv-qualifiziertes) void ist:

auto f() {}              // gibt void zurück
auto g() { return f(); } // gibt void zurück
auto* x() {}             // Fehler: auto* kann nicht von void abgeleitet werden

Sobald eine return-Anweisung in einer Funktion gesehen wurde, kann der von dieser Anweisung abgeleitete Rückgabetyp im Rest der Funktion verwendet werden, einschließlich in anderen return-Anweisungen:

auto sum(int i)
{
    if (i == 1)
        return i;              // Rückgabetyp von sum ist int
    else
        return sum(i - 1) + i; // OK: Rückgabetyp von sum ist bereits bekannt
}

Wenn die return-Anweisung eine geschweifte Initialisierungsliste verwendet, ist Deduktion nicht erlaubt:

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

Virtual functions und coroutines (seit C++20) können keine Rückgabetyp-Ableitung verwenden:

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

Function templates außer user-defined conversion functions können die Rückgabetyp-Ableitung verwenden. Die Ableitung erfolgt bei der Instanziierung, selbst wenn der Ausdruck in der return-Anweisung nicht dependent ist. Diese Instanziierung befindet sich nicht in einem immediate context für SFINAE .

template<class T>
auto f(T t) { return t; }
typedef decltype(f(1)) fint_t;    // instanziiert f<int> um den Rückgabetyp abzuleiten
template<class T>
auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // instanziiert beide fs um Rückgabetypen zu bestimmen,
                                  // wählt die zweite Template-Überladung

Neudeklarationen oder Spezialisierungen von Funktionen oder Funktionsvorlagen, die Rückgabetypableitung verwenden, müssen dieselben Rückgabetyp-Platzhalter verwenden:

auto f(int num) { return num; }
// int f(int num);            // Fehler: kein Platzhalter-Rückgabetyp
// decltype(auto) f(int num); // Fehler: anderer Platzhalter
template<typename T>
auto g(T t) { return t; }
template auto g(int);     // OK: Rückgabetyp ist int
// template char g(char); // Fehler: keine Spezialisierung des Primär-Templates g

Ebenso dürfen Neudeklarationen oder Spezialisierungen von Funktionen oder Funktionsvorlagen, die keine Rückgabetypableitung verwenden, keinen Platzhalter verwenden:

int f(int num);
// auto f(int num) { return num; } // Fehler: keine Neudeklaration von f
template<typename T>
T g(T t) { return t; }
template int g(int);      // OK: Spezialisierung von T als int
// template auto g(char); // Fehler: keine Spezialisierung des primären Templates g

Explizite Instanziierungsdeklarationen instanziieren selbst keine Funktions-Templates, die Rückgabetypableitung verwenden:

template<typename T>
auto f(T t) { return t; }
extern template auto f(int); // instanziiert f<int> nicht
int (*p)(int) = f; // instanziiert f<int>, um dessen Rückgabetyp zu bestimmen,
                   // aber eine explizite Instanziierungsdefinition
                   // ist weiterhin irgendwo im Programm erforderlich

Falls einer der Funktionsparameter einen Platzhalter (entweder auto oder einen Konzepttyp ) verwendet, ist die Funktionsdeklaration stattdessen eine Abgekürzte Funktions-Template-Deklaration :

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

Eine Parameterdeklaration mit dem Spezifizierer this (Syntax ( 2 ) / ( 5 ) ) deklariert einen Expliziten Objektparameter .

Ein expliziter Objektparameter kann kein Funktionsparameter-Pack sein und kann nur als erster Parameter der Parameterliste in den folgenden Deklarationen erscheinen:

• einer Deklaration einer Elementfunktion oder Elementfunktions-Template
• einer Expliziten Instanziierung oder Expliziten Spezialisierung einer templatisierten Elementfunktion
• einer Lambda -Deklaration

Eine Elementfunktion mit einem expliziten Objektparameter unterliegt den folgenden Einschränkungen:

• Die Funktion ist nicht static .
• Die Funktion ist nicht virtual .
• Der Deklarator der Funktion enthält keine cv - und ref -Qualifizierer.

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

• Wenn die Ausnahmespezifikation nicht-werfend ist, lautet der Typ der deklarierten Funktion
  „abgeleiteter-Deklarator-Typen-Liste noexcept Funktion von
  Parameter-Typen-Liste cv  (optional) ref   (optional) zurückgebend T “.

In Syntax (2) , unter der Annahme, dass noptr-declarator als eigenständige Deklaration betrachtet wird, und mit dem Typ der qualified-id oder unqualified-id in noptr-declarator als "derived-declarator-type-list T " ( T muss in diesem Fall auto sein):

• Wenn die Ausnahmespezifikation nicht-werfend ist, lautet der Typ der deklarierten Funktion
  "derived-declarator-type-list noexcept Funktion von
  parameter-type-list cv  (optional) ref   (optional) zurückgebend trailing ".

• Der (bis C++17) Andernfalls lautet der (seit C++17) Typ der deklarierten Funktion
  "derived-declarator-type-list Funktion von
  parameter-type-list cv  (optional) ref   (optional) zurückgebend trailing ".

attr , falls vorhanden, gilt für den Funktionstyp.

• ref

• trailing requires clause

• Wenn die Funktion eine Nicht-Template- friend -Funktion mit einer trailing requires -Klausel ist, enthält ihre Signatur die umschließende Klasse anstelle des umschließenden Namensraums. Die Signatur enthält ebenfalls die trailing requires -Klausel.

Wenn eine Funktionsdefinition einen virt-specs enthält, muss sie eine Memberfunktion definieren.

Wenn eine Funktionsdefinition eine requires-clause enthält, muss sie eine templatierte Funktion definieren.

Defaultierte Funktionen

Wenn die Funktionsdefinition von der Syntax ( 3 ) ist, wird die Funktion als explizit defaulted definiert.

Eine explizit defaulted Funktion muss eine special member function oder comparison operator function (since C++20) sein und darf keine default argument haben.

Eine explizit default-spezifizierte spezielle Elementfunktion F1 darf sich von der entsprechenden speziellen Elementfunktion F2 unterscheiden, die implizit deklariert worden wäre, wie folgt:

• F1 und F2 können unterschiedliche ref und/oder except haben.
• Wenn F2 einen Nicht-Objekt-Parameter vom Typ const C & hat, kann der entsprechende Nicht-Objekt-Parameter von F1 vom Typ C& sein.

Wenn sich der Typ von F1 vom Typ von F2 auf eine andere Weise unterscheidet, als durch die vorhergehenden Regeln erlaubt, dann:

• Wenn F1 ein Zuweisungsoperator ist und der Rückgabetyp von F1 sich vom Rückgabetyp von F2 unterscheidet oder der Nicht-Objekt-Parametertyp von F1 kein Referenztyp ist, ist das Programm fehlerhaft.
• Andernfalls, wenn F1 in seiner ersten Deklaration explizit als default deklariert ist, wird es als gelöscht definiert.
• Andernfalls ist das Programm fehlerhaft.

Eine Funktion, die bei ihrer ersten Deklaration explizit als default deklariert wird, ist implizit inline und ist implizit constexpr, wenn sie eine constexpr-Funktion sein kann.

struct S
{
    S(int a = 0) = default;             // Fehler: Standardargument
    void operator=(const S&) = default; // Fehler: Nicht übereinstimmender Rückgabetyp
    ~S() noexcept(false) = default;     // OK, andere Ausnahmespezifikation
private:
    int i;
    S(S&);          // OK, privater Kopierkonstruktor
};
S::S(S&) = default; // OK, definiert Kopierkonstruktor

Explizit defaulted Funktionen und implizit deklarierte Funktionen werden zusammen als defaulted Funktionen bezeichnet. Ihre tatsächlichen Definitionen werden implizit bereitgestellt, siehe die entsprechenden Seiten für Details.

Gelöschte Funktionen

Wenn die Funktionsdefinition die Syntax ( 4 ) oder ( 5 ) (since C++26) hat, ist die Funktion als explizit gelöscht definiert.

Jede Verwendung einer gelöschten Funktion ist fehlerhaft (das Programm wird nicht kompilieren). Dies umfasst Aufrufe, sowohl explizite (mit einem Funktionsaufrufoperator) als auch implizite (ein Aufruf eines gelöschten überladenen Operators, einer speziellen Memberfunktion, einer Allokationsfunktion etc.), das Bilden eines Zeigers oder Zeigers-auf-Member auf eine gelöschte Funktion, und sogar die Verwendung einer gelöschten Funktion in einem Ausdruck, der nicht potenziell ausgewertet wird.

Eine nicht-reine virtuelle Memberfunktion kann als gelöscht definiert werden, auch wenn sie implizit ODR-used wird. Eine gelöschte Funktion kann nur durch gelöschte Funktionen überschrieben werden, und eine nicht-gelöschte Funktion kann nur durch nicht-gelöschte Funktionen überschrieben werden.

Wenn die Funktion überladen ist, Overload Resolution findet zuerst statt, und das Programm ist nur dann fehlerhaft, wenn die gelöschte Funktion ausgewählt wurde:

struct T
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete("new[] is deleted"); // seit C++26
};
T* p = new T;    // Fehler: Versuch, gelöschten T::operator new aufzurufen
T* p = new T[5]; // Fehler: Versuch, gelöschten T::operator new[] aufzurufen,
                 //        gibt eine Diagnosemeldung "new[] is deleted" aus

Die gelöschte Definition einer Funktion muss die erste Deklaration in einer Übersetzungseinheit sein: Eine zuvor deklarierte Funktion kann nicht als gelöscht neu deklariert werden:

struct T { T(); };
T::T() = delete; // Fehler: Muss bei der ersten Deklaration gelöscht werden

Vom Benutzer bereitgestellte Funktionen

Eine Funktion ist user-provided , wenn sie user-declared ist und nicht explizit defaulted oder deleted bei ihrer ersten Deklaration. Eine user-provided explicitly-defaulted Funktion (d.h. explizit defaulted nach ihrer ersten Deklaration) wird an dem Punkt definiert, an dem sie explizit defaulted wird; wenn eine solche Funktion implizit als deleted definiert wird, ist das Programm ill-formed. Das Deklarieren einer Funktion als defaulted nach ihrer ersten Deklaration kann effiziente Ausführung und prägnante Definition bieten, während sie eine stabile binäre Schnittstelle zu einer sich entwickelnden Codebasis ermöglicht.

// Alle speziellen Elementfunktionen von "trivial" sind
// jeweils in ihren ersten Deklarationen standardmäßig implementiert,
// sie sind nicht benutzerbereitgestellt
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(); // erste Deklaration
};
// nicht in der ersten Deklaration standardmäßig implementiert,
// ist benutzerbereitgestellt und wird hier definiert
nontrivial::nontrivial() = default;

Auflösung von Mehrdeutigkeiten

Im Falle einer Mehrdeutigkeit zwischen einem Funktionsrumpf und einem Initialisierer , der mit { oder = (seit C++26) beginnt, wird die Mehrdeutigkeit durch Überprüfung des Typs des Deklarator-Identifiers von noptr-declarator  aufgelöst:

• Wenn der Typ ein Funktionstyp ist, wird die mehrdeutige Token-Sequenz als Funktionsrumpf behandelt.
• Andernfalls wird die mehrdeutige Token-Sequenz als Initialisierer behandelt.

using T = void(); // Funktions-Typ
using U = int;    // Nicht-Funktions-Typ
T a{}; // definiert eine Funktion, die nichts tut
U b{}; // wertinitialisiert ein int-Objekt
T c = delete("hello"); // definiert eine Funktion als gelöscht
U d = delete("hello"); // kopierinitialisiert ein int-Objekt mit
                       // dem Ergebnis eines delete-Ausdrucks (fehlerhaft)

__func__

Im Funktionsrumpf ist die funktionslokale vordefinierte Variable __func__ definiert, als ob durch

static const char __func__[] = "Funktionsname";

Diese Variable hat Blockgültigkeit und statische Speicherdauer:

struct S
{
    S(): s(__func__) {} // OK: Initialisierungsliste ist Teil des Funktionsrumpfs
    const char* s;
};
void f(const char* s = __func__); // Fehler: Parameterliste ist Teil des Deklarators

#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

Funktionsvertragsspezifizierer

Funktionsdeklarationen und Lambda-Ausdrücke können eine Sequenz von Funktionsvertragsspezifizierern  enthalten, jeder Spezifizierer hat folgende Syntax:

Precondition assertion und Postcondition assertion werden zusammen als function contract assertion  bezeichnet.

Ein Funktionsvertragsassertion ist eine Vertragsassertion , die einer Funktion zugeordnet ist. Das Prädikat einer Funktionsvertragsassertion wird kontextuell konvertiert zu bool .

Die folgenden Funktionen können nicht mit Funktionsvertragsspezifizierern deklariert werden:

• virtuelle Funktionen
• gelöschte Funktionen
• Funktionen standardmäßig definiert bei ihrer ersten Deklaration

Vorbedingungs-Assertions

Eine Vorbedingungsassertion ist mit dem Eintritt in eine Funktion verbunden:

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

Nachbedingungs-Zusicherungen

Eine Nachbedingungsassertion ist mit dem normalen Verlassen einer Funktion verbunden.

Wenn eine Nachbedingungsassertion einen identifier hat, führt der Funktionsvertrag-Spezifizierer identifier als Namen einer result binding der zugehörigen Funktion ein. Eine result binding bezeichnet das Objekt oder die Referenz, die durch den Aufruf dieser Funktion zurückgegeben wird. Der Typ einer result binding ist der Rückgabetyp ihrer zugehörigen Funktion.

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))
        // Beenden über eine Exception verursacht niemals Vertragsverletzung
        throw std::invalid_argument("Ungültiges Argument");
    return std::sin(num);
}

Wenn eine Nachbedingungs-Assertion einen Bezeichner  besitzt und der Rückgabetyp der zugehörigen Funktion (möglicherweise cv-qualifiziert) void ist, ist das Programm fehlerhaft:

void f() post(r : r > 0); // Fehler: kein Wert kann an „r“ gebunden werden

Wenn der deklarierte Rückgabetyp einer nicht-templatisierten Funktion einen Platzhaltertyp enthält, kann eine Nachbedingungsassertion mit einem Bezeichner  nur in einer Funktionsdefinition erscheinen:

auto g(auto&) post(r : r >= 0); // OK, „g“ ist ein Template
auto h() post(r : r >= 0);      // Fehler: Rückgabewert kann nicht benannt werden
auto k() post(r : r >= 0)       // OK, „k“ ist eine Definition
{
    return 0;
}

Vertragskonsistenz

Eine Neudeklaration D einer Funktion oder Funktionsvorlage func muss entweder keine Vertragsspezifikationen oder dieselben Vertragsspezifikationen wie jede erste Deklaration F aufweisen, die von D aus erreichbar ist. Wenn D und F sich in verschiedenen Übersetzungseinheiten befinden, ist eine Diagnose nur erforderlich, wenn D an ein benanntes Modul angehängt ist.

Wenn eine Deklaration F1 eine erste Deklaration von func in einer Übersetzungseinheit ist und eine Deklaration F2 eine erste Deklaration von func in einer anderen Übersetzungseinheit ist, F1 und F2 müssen dieselben contract-specs  angeben, keine Diagnose erforderlich.

Zwei contract-specs sind gleich, wenn sie aus denselben Funktionskontraktspezifizierern in derselben Reihenfolge bestehen.

Ein Funktionsvertragsspezifizierer C1 auf einer Funktionsdeklaration D1 ist derselbe wie ein Funktionsvertragsspezifizierer C2 auf einer Funktionsdeklaration D2 wenn alle folgenden Bedingungen erfüllt sind:

• Die Prädikate von C1 und C2 würden die One-Definition-Rule erfüllen, wenn sie in Funktionsdefinitionen an den Deklarationen D1 und D2 platziert würden (falls D1 und D2 in verschiedenen Übersetzungseinheiten sind, verhalten sich entsprechende Entitäten innerhalb jedes Prädikats wie eine einzelne Entität mit einer einzigen Definition), außer für folgende Umbenennungen:
  • Die Umbenennung der Parameter der deklarierten Funktion.
  • Die Umbenennung von Template-Parametern eines das deklarierte Funktionstemplate umschließenden Templates.
  • Die Umbenennung der Ergebnisbindung (falls vorhanden).
• Sowohl C1 als auch C2 haben einen Bezeichner oder keiner von beiden hat einen.

Wenn diese Bedingung allein aufgrund des Vergleichs zweier Lambda-Ausdrücke, die innerhalb der Prädikate enthalten sind, nicht erfüllt ist, ist keine Diagnose erforderlich.

bool b1, b2;
void f() pre (b1) pre([]{ return b2; }());
void f(); // OK, Funktionsvertragsspezifizierer ausgelassen
void f() pre (b1) pre([]{ return b2; }()); // Fehler: Closures haben unterschiedliche Typen
void f() pre (b1); // Fehler: Funktionsvertragsspezifizierer sind unterschiedlich
int g() post(r : b1);
int g() post(b1); // Fehler: Keine Ergebnisbindung
namespace N
{
    void h() pre (b1);
    bool b1;
    void h() pre (b1); // Fehler: Funktionsvertragsspezifizierer unterscheiden sich
                       //        gemäß der One-Definition-Rule
}