Namespaces
Variants

std::function<R(Args...)>:: 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
function ( ) noexcept ;
(1) (seit C++11)
function ( std:: nullptr_t ) noexcept ;
(2) (seit C++11)
function ( const function & other ) ;
(3) (seit C++11)
(4)
function ( function && other ) ;
(seit C++11)
(bis C++20)
function ( function && other ) noexcept ;
(seit C++20)
template < class F >
function ( F && f ) ;
(5) (seit C++11)
template < class Alloc >
function ( std:: allocator_arg_t , const Alloc & alloc ) noexcept ;
(6) (seit C++11)
(entfernt in C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

std:: nullptr_t ) noexcept ;
(7) (seit C++11)
(entfernt in C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

const function & other ) ;
(8) (seit C++11)
(entfernt in C++17)
template < class Alloc >

function ( std:: allocator_arg_t , const Alloc & alloc,

function && other ) ;
(9) (seit C++11)
(entfernt in C++17)
template < class F, class Alloc >
function ( std:: allocator_arg_t , const Alloc & alloc, F f ) ;
(10) (seit C++11)
(entfernt in C++17)

Konstruiert ein std::function aus verschiedenen Quellen.

1,2) Erstellt eine leere std::function .
3) Kopiert das Ziel von other zum Ziel von * this .
Wenn other leer ist, * this wird unmittelbar nach dem Aufruf ebenfalls leer sein.
4) Verschiebt das Ziel von other zum Ziel von * this .
Wenn other leer ist, * this wird unmittelbar nach dem Aufruf ebenfalls leer sein.
other befindet sich direkt nach dem Aufruf in einem gültigen, aber nicht spezifizierten Zustand.
5) Initialisiert das Ziel mit std:: forward < F > ( f ) . Das Ziel ist vom Typ std:: decay < F > :: type .
Wenn f ein Nullzeiger auf Funktion, ein Nullzeiger auf Member oder ein leerer Wert einer std::function Spezialisierung ist, * this wird unmittelbar nach dem Aufruf leer sein.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
(seit C++23)
  • Ein Lvalue vom Typ std:: decay < F > :: type ist aufrufbar für Argumenttypen Args... und Rückgabetyp R .

Falls std:: is_copy_constructible_v < std:: decay_t < F >> oder std:: is_constructible_v < std:: decay_t < F > , F > den Wert false hat, ist das Programm fehlerhaft.

(seit C++23)
Wenn F nicht CopyConstructible ist, ist das Verhalten undefiniert.
6-10) Gleich wie (1-5) außer dass alloc verwendet wird, um Speicher für alle internen Datenstrukturen zu allozieren, die die std::function verwenden könnte.

Wenn das Ziel ein Funktionszeiger oder ein std::reference_wrapper ist, ist die Small-Object-Optimierung garantiert, das heißt, diese Ziele werden immer direkt innerhalb des std::function -Objekts gespeichert, es findet keine dynamische Speicherallokation statt. Andere große Objekte können im dynamisch allokierten Speicher konstruiert werden und werden durch das std::function -Objekt über einen Zeiger angesprochen.

Inhaltsverzeichnis

Parameter

other - das Funktionsobjekt, das zur Initialisierung von * this verwendet wird
f - ein aufrufbares Objekt, das zur Initialisierung von * this verwendet wird
alloc - ein Allocator , der für interne Speicherzuweisung verwendet wird
Typanforderungen
-
Alloc muss die Anforderungen von Allocator erfüllen.

Ausnahmen

3,8,9) Wirft keine Ausnahme, falls other 's Ziel ein Funktionszeiger oder ein std::reference_wrapper ist, andernfalls kann std::bad_alloc oder eine beliebige Ausnahme geworfen werden, die vom Konstruktor ausgelöst wird, der zum Kopieren oder Verschieben des gespeicherten aufrufbaren Objekts verwendet wird.
4) Wirft keine Ausnahme, wenn other 's Ziel ein Funktionszeiger oder ein std::reference_wrapper ist, andernfalls kann std::bad_alloc oder jede Ausnahme geworfen werden, die vom Konstruktor ausgelöst wird, der zum Kopieren oder Verschieben des gespeicherten aufrufbaren Objekts verwendet wird.
(until C++20)
5,10) Wirft keine Ausnahme, falls f ein Funktionszeiger oder ein std::reference_wrapper ist, andernfalls kann std::bad_alloc oder jede durch den Kopierkonstruktor des gespeicherten aufrufbaren Objekts ausgelöste Ausnahme geworfen werden.

Hinweise

std::function 's Allokatorunterstützung war schlecht spezifiziert und inkonsistent implementiert. Einige Implementierungen bieten die Überladungen ( 6-10 ) überhaupt nicht an, einige bieten die Überladungen an, ignorieren jedoch das übergebene Allokatorargument, und einige bieten die Überladungen an und verwenden den übergebenen Allokator für die Konstruktion, jedoch nicht, wenn das std::function neu zugewiesen wird. Infolgedessen wurde die Allokatorunterstützung in C++17 entfernt.

Beispiel

Diesen Code ausführen 
#include <functional>
#include <iostream>
#include <utility>
void print_num(int i) { std::cout << "print_num(" << i << ")\n"; }
int main()
{
    std::function<void(int)> func1; // (1) leerer Konstruktor
    try
    {
        func1(333 << 1);
    }
    catch (const std::bad_function_call& ex)
    {
        std::cout << "1) " << ex.what() << '\n';
    }
    std::function<void(int)> func2{nullptr}; // (2) leerer Konstruktor
    try
    {
        func1(222 * 3);
    }
    catch (const std::bad_function_call& ex)
    {
        std::cout << "2) " << ex.what() << '\n';
    }
    func1 = print_num; // initialisiert func1 mit Zuweisungsoperator
    std::function<void(int)> func3{func1}; // (3) Kopierkonstruktor
    func3(33);
    std::function<void(int)> func4{std::move(func3)}; // (4) Move-Konstruktor,
                                                      // func3 in nicht spezifiziertem Zustand
    func4(44);
    std::function<void(int)> func5{print_num}; // (5) Konstruktor mit Funktion
    func5(55);
    // (5) Konstruktor mit Lambda
    std::function<void(int)> func6([](int i) { std::cout << "lambda(" << i << ")\n"; });
    func6(66);
}

Mögliche Ausgabe: 

1) bad_function_call
2) bad_function_call
print_num(33)
print_num(44)
print_num(55)
lambda(66)

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2132 C++11 Überladungen ( 5,10 ) könnten mehrdeutig sein eingeschränkt
LWG 2774 C++11 ( 5,10 ) führte eine zusätzliche Verschiebung aus entfernt

Siehe auch

Konstruiert ein neues std::move_only_function Objekt
(Öffentliche Mitgliedsfunktion von std::move_only_function )