Functions

Funktionen sind C++-Entitäten, die eine Folge von statements (einen function body ) mit einem name und einer Liste von null oder mehr function parameters verknüpfen.

// Funktionsname: "isodd"
// Parameterliste hat einen Parameter, mit Namen "n" und Typ int
// Der Rückgabetyp ist bool
bool isodd(int n)
{                 // Der Körper der Funktion beginnt
    return n % 2;
}                 // Der Körper der Funktion endet

Wenn eine Funktion aufgerufen wird, z.B. in einem Funktionsaufrufausdruck , werden die Parameter aus den Argumenten initialisiert (entweder am Aufrufort bereitgestellt oder standardmäßig vorgegeben ) und die Anweisungen im Funktionsrumpf werden ausgeführt. Wenn die Parameterliste mit ... endet, können zusätzliche Argumente an die Funktion übergeben werden; eine solche Funktion wird als variadische Funktion bezeichnet.

int main()
{
    for (int arg : {-3, -2, -1, 0, 1, 2, 3})
        std::cout << isodd(arg) << ' '; // isodd wird 7 Mal aufgerufen, jedes
                                        // Mal wird n aus arg kopierinitialisiert
}

Unqualified Funktionsnamen in Funktionsaufrufausdrücken werden mit einem zusätzlichen Satz von Regeln gesucht, der als "argument-dependent lookup" (ADL) bezeichnet wird.

Eine Funktion kann durch Zurückkehren oder durch Werfen einer Exception beendet werden.

Eine Funktionsdeklaration kann in jedem Gültigkeitsbereich erscheinen, aber eine Funktionsdefinition darf nur im Namensraum-Gültigkeitsbereich oder, für Member- und Friend-Funktionen , im Klassen-Gültigkeitsbereich erscheinen. Eine Funktion, die im Klassenkörper ohne Friend-Spezifizierer deklariert wird, ist eine Klassen-Member-Funktion. Solche Funktionen haben viele zusätzliche Eigenschaften, siehe Member-Funktionen für Details.

Funktionen sind keine Objekte: Es gibt keine Arrays von Funktionen und Funktionen können nicht als Wert übergeben oder von anderen Funktionen zurückgegeben werden. Zeiger und Referenzen auf Funktionen (mit Ausnahme von der main-Funktion und den meisten Standardbibliotheksfunktionen (seit C++20) ) sind erlaubt und können dort verwendet werden, wo diese Funktionen selbst nicht verwendet werden können. Daher sagen wir, dass diese Funktionen "addressierbar" sind.

Jede Funktion hat einen Typ, der sich aus dem Rückgabetyp der Funktion, den Typen aller Parameter (nach Array-zu-Zeiger- und Funktion-zu-Zeiger-Transformationen, siehe Parameterliste ) , ob die Funktion noexcept ist oder nicht (seit C++17) , und für nicht-statische Memberfunktionen, CV-Qualifikation und Ref-Qualifikation (seit C++11) zusammensetzt. Funktionstypen haben auch Sprachbindung . Es gibt keine CV-qualifizierten Funktionstypen (nicht zu verwechseln mit den Typen von CV-qualifizierten Funktionen wie int f ( ) const ; oder Funktionen, die CV-qualifizierte Typen zurückgeben, wie std:: string const f ( ) ; ). Jeder CV-Qualifizierer wird ignoriert, wenn er zu einem Alias für einen Funktionstyp hinzugefügt wird.

Mehrere Funktionen im selben Geltungsbereich können denselben Namen haben, solange ihre Parameterlisten und, für nicht-statische Memberfunktionen, cv /ref (since C++11) -Qualifikationen unterschiedlich sind. Dies wird als Function Overloading bezeichnet. Funktionsdeklarationen, die sich nur im Rückgabetyp und der noexcept-Spezifikation (since C++17) unterscheiden, können nicht überladen werden. Die Adresse einer überladenen Funktion wird anders bestimmt.

Funktionsobjekte

Neben Funktionslvalues unterstützt der Funktionsaufrufausdruck Zeiger auf Funktionen und jeden Wert eines Klassentyps, der den Funktionsaufrufoperator überlädt oder in einen Funktionszeiger konvertierbar ist (einschließlich Lambda-Ausdrücken ) (seit C++11) . Zusammen werden diese Typen als FunctionObject s bezeichnet und werden allgegenwärtig in der C++-Standardbibliothek verwendet, siehe beispielsweise die Verwendungen von BinaryPredicate und Compare .

Die Standardbibliothek bietet auch eine Reihe vordefinierter Funktionsobjekt-Templates sowie Methoden zum Zusammensetzen neuer (einschließlich std::less , std::mem_fn , std::bind , std::function (seit C++11) , std::not_fn (seit C++17) , std::bind_front (seit C++20) , std::bind_back , std::move_only_function (seit C++23) , std::copyable_function , und std::function_ref (seit C++26) ).