std::function<R(Args...)>::function

function() noexcept;

function( std::nullptr_t ) noexcept;

function( const function& other );

function( function&& other );

function( function&& other ) noexcept;

template< class F > 
function( F&& f );

template< class Alloc > 
function( std::allocator_arg_t, const Alloc& alloc ) noexcept;

template< class Alloc > 
function( std::allocator_arg_t, const Alloc& alloc, 
          std::nullptr_t ) noexcept;

template< class Alloc > 
function( std::allocator_arg_t, const Alloc& alloc, 
          const function& other );

template< class Alloc > 
function( std::allocator_arg_t, const Alloc& alloc, 
          function&& other );

template< class F, class Alloc > 
function( std::allocator_arg_t, const Alloc& alloc, F f );

Konstruiert ein std::function aus einer Vielzahl von Quellen.

Wenn das Ziel ein Funktionszeiger oder ein std::reference_wrapper ist, ist eine Optimierung für kleine Objekte garantiert, d.h., diese Ziele werden immer direkt innerhalb des std::function-Objekts gespeichert, es findet keine dynamische Allokation statt. Andere große Objekte können im dynamisch allokierten Speicher konstruiert und über einen Zeiger durch das std::function-Objekt zugegriffen werden.

Parameter

Ausnahmen

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

#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);
}

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.

Siehe auch