Namespaces
Variants

std:: function

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
std::function
Definiert im Header <functional>
template < class >
class function ; /* undefined */
(seit C++11)
template < class R, class ... Args >
class function < R ( Args... ) > ;
(seit C++11)

Die Klassenvorlage std::function ist ein allgemeiner polymorpher Funktionswrapper. Instanzen von std::function können jedes CopyConstructible Callable Ziel speichern, kopieren und aufrufen -- Funktionen (über Zeiger darauf), Lambda-Ausdrücke , Bind-Ausdrücke , oder andere Funktionsobjekte, sowie Zeiger auf Elementfunktionen und Zeiger auf Datenelemente.

Das gespeicherte aufrufbare Objekt wird als Target (Zielobjekt) von std::function bezeichnet. Wenn eine std::function kein Target enthält, wird sie als empty (leer) bezeichnet. Der Aufruf des Target einer empty std::function führt dazu, dass eine std::bad_function_call -Exception ausgelöst wird.

std::function erfüllt die Anforderungen von CopyConstructible und CopyAssignable .

Inhaltsverzeichnis

Mitgliedertypen

Typ Definition
result_type R
argument_type
(veraltet in C++17) (entfernt in C++20) 		T falls sizeof... ( Args ) == 1 und T der erste und einzige Typ in Args... ist
first_argument_type
(veraltet in C++17) (entfernt in C++20) 		T1 falls sizeof... ( Args ) == 2 und T1 der erste der beiden Typen in Args... ist
second_argument_type
(veraltet in C++17) (entfernt in C++20) 		T2 falls sizeof... ( Args ) == 2 und T2 der zweite der beiden Typen in Args... ist

Memberfunktionen

Konstruiert eine neue std::function Instanz
(öffentliche Member-Funktion)
Zerstört eine std::function Instanz
(öffentliche Member-Funktion)
Weist ein neues Ziel zu
(öffentliche Member-Funktion)
Tauscht die Inhalte aus
(öffentliche Member-Funktion)
(entfernt in C++17)
Weist ein neues Ziel zu
(öffentliche Member-Funktion)
Prüft, ob ein Ziel enthalten ist
(öffentliche Member-Funktion)
Ruft das Ziel auf
(öffentliche Member-Funktion)
Ziel-Zugriff
Ermittelt den typeid des gespeicherten Ziels
(öffentliche Member-Funktion)
Ermittelt einen Zeiger auf das gespeicherte Ziel
(öffentliche Member-Funktion)

Nicht-Member-Funktionen

(C++11)
spezialisiert den std::swap Algorithmus
(Funktions-Template)
(entfernt in C++20)
vergleicht ein std::function mit nullptr
(Funktions-Template)

Hilfsklassen

(C++11) (bis C++17)
spezialisiert das std::uses_allocator Type-Trait
(Klassen-Template-Spezialisierung)

Deduktionsleitfäden (seit C++17)

Hinweise

Besondere Vorsicht ist geboten, wenn ein std::function , dessen Ergebnistyp eine Referenz ist, mit einem Lambda-Ausdruck ohne nachgestellten Rückgabetyp initialisiert wird. Aufgrund der Funktionsweise der auto-Deduktion gibt ein solcher Lambda-Ausdruck stets einen Prvalue zurück. Daher wird die resultierende Referenz in der Regel an ein Temporär gebunden, dessen Lebensdauer endet, wenn std::function::operator() zurückkehrt.

(bis C++23)

Wenn ein std::function , das eine Referenz zurückgibt, mit einer Funktion oder einem Funktionsobjekt initialisiert wird, das einen Prvalue zurückgibt (einschließlich eines Lambda-Ausdrucks ohne nachgestellten Rückgabetyp), ist das Programm fehlerhaft, da das Binden der zurückgegebenen Referenz an ein temporäres Objekt verboten ist.

(seit C++23) 
std::function<const int&()> F([] { return 42; }); // Fehler ab C++23: Kann die zurückgegebene Referenz
                                                  // nicht an ein temporäres Objekt binden
int x = F(); // Undefiniertes Verhalten bis C++23: Das Ergebnis von F() ist eine hängende Referenz
std::function<int&()> G([]() -> int& { static int i{0x2A}; return i; }); // OK
std::function<const int&()> H([i{052}] -> const int& { return i; }); // OK

Beispiel

Diesen Code ausführen 
#include <functional>
#include <iostream>
struct Foo
{
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_ + i << '\n'; }
    int num_;
};
void print_num(int i)
{
    std::cout << i << '\n';
}
struct PrintNum
{
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
int main()
{
    // Speichere eine freie Funktion
    std::function<void(int)> f_display = print_num;
    f_display(-9);
    // Speichere eine Lambda-Funktion
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
    // Speichere das Ergebnis eines Aufrufs von std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
    // Speichere einen Aufruf einer Member-Funktion
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
    // Speichere einen Aufruf eines Daten-Member-Zugriffs
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
    // Speichere einen Aufruf einer Member-Funktion und eines Objekts
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind(&Foo::print_add, foo, _1);
    f_add_display2(2);
    // Speichere einen Aufruf einer Member-Funktion und eines Objektzeigers
    std::function<void(int)> f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
    f_add_display3(3);
    // Speichere einen Aufruf eines Funktionsobjekts
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
    auto factorial = [](int n)
    {
        // Speichere ein Lambda-Objekt zur Emulation von "rekursivem Lambda"; beachte zusätzlichen Overhead
        std::function<int(int)> fac = [&](int n) { return (n < 2) ? 1 : n * fac(n - 1); };
        // Beachte: "auto fac = [&](int n) {...};" funktioniert nicht bei rekursiven Aufrufen
        return fac(n);
    };
    for (int i{5}; i != 8; ++i)
        std::cout << i << "! = " << factorial(i) << ";  ";
    std::cout << '\n';
}

Mögliche Ausgabe: 

-9
42
31337
314160
314160
num_: 314159
314161
314162
18
5! = 120;  6! = 720;  7! = 5040;

Siehe auch

(C++23)
Nur-verschiebbarer Wrapper für jedes aufrufbare Objekt, das Qualifizierer in einer gegebenen Aufrufsignatur unterstützt
(Klassentemplate)
(C++26)
Kopierbarer Wrapper für jedes kopierkonstruierbare aufrufbare Objekt, das Qualifizierer in einer gegebenen Aufrufsignatur unterstützt
(Klassentemplate)
(C++26)
Nicht-besitzender Wrapper für jedes aufrufbare Objekt
(Klassentemplate)
(C++11)
Die Ausnahme, die beim Aufruf eines leeren std::function geworfen wird
(Klasse)
(C++11)
Erzeugt ein Funktionsobjekt aus einem Zeiger auf ein Element
(Funktionstemplate)
typeid Fragt Informationen über einen Typ ab und gibt ein std::type_info Objekt zurück, das den Typ repräsentiert