function-Klasse

Artikel
10/12/2023

Wrapper für ein aufrufbares Objekt.

Syntax

template <class Fty>
class function  // Fty of type Ret(T1, T2, ..., TN)
    : public unary_function<T1, Ret>       // when Fty is Ret(T1)
    : public binary_function<T1, T2, Ret>  // when Fty is Ret(T1, T2)
{
public:
    typedef Ret result_type;

    function();
    function(nullptr_t);
    function(const function& right);
    template <class Fty2>
        function(Fty2 fn);
    template <class Fty2, class Alloc>
        function(reference_wrapper<Fty2>, const Alloc& Ax);

    template <class Fty2, class Alloc>
        void assign(Fty2, const Alloc& Ax);
    template <class Fty2, class Alloc>
        void assign(reference_wrapper<Fty2>, const Alloc& Ax);
    function& operator=(nullptr_t);
    function& operator=(const function&);
    template <class Fty2>
        function& operator=(Fty2);
    template <class Fty2>
        function& operator=(reference_wrapper<Fty2>);

    void swap(function&);
    explicit operator bool() const;

    result_type operator()(T1, T2, ....., TN) const;
    const std::type_info& target_type() const;
    template <class Fty2>
        Fty2 *target();

    template <class Fty2>
        const Fty2 *target() const;

    template <class Fty2>
        void operator==(const Fty2&) const = delete;
    template <class Fty2>
        void operator!=(const Fty2&) const = delete;
};

Parameter

Fty
Der zu umschließende Funktionstyp.

Ax
Die Zuweisungsfunktion.

Hinweise

Die Klassenvorlage ist ein Anrufwrapper, dessen Anrufsignatur lautet Ret(T1, T2, ..., TN). Sie verwenden es, um verschiedene aufrufbare Objekte in einen uniform Wrapper einzuschließen.

Einige Memberfunktionen akzeptieren einen Operanden, der das gewünschte Zielobjekt benennt. Sie können einen solchen Operanden wie folgt festlegen:

fn: Das aufrufbare Objekt fn; nach dem Aufruf des function Objekts enthält eine Kopie von fn

fnref: Das aufgerufene Objekt mit dem Namen fnref.get(); nach dem Aufruf des function Objekts enthält einen Verweis auf fnref.get()

right: Das aufrufbare Objekt( falls vorhanden) des function Objekts right

npc: Ein Nullzeiger; nachdem der Aufruf des function Objekts leer ist

In allen Fällen INVOKE(f, t1, t2, ..., tN), wo f das aufrufbare Objekt und t1, t2, ..., tN lvalues von Typen T1, T2, ..., TN sind, muss wohlgeformt sein und, wenn Ret nicht nichtig, konvertierbar in Ret.

Ein leeres function Objekt enthält kein aufrufbares Objekt oder einen Verweis auf ein aufrufbares Objekt.

Member

Konstruktoren

Name	Beschreibung
function	Konstruiert einen Wrapper, der entweder leer ist oder ein aufrufbares Objekt eines willkürlichen Typs mit einer festen Signatur speichert.

TypeDefs

Name	Beschreibung
Result_type	Der Rückgabetyp des gespeicherten aufrufbaren Objekts.

Funktionen

Name	Beschreibung
assign	Weist ein aufrufbares Objekt diesem Funktionsobjekt zu.
swap	Tauscht zwei aufrufbare Objekte miteinander.
Ziel	Prüft, ob das gespeicherte aufrufbare Objekt wie festgelegt aufrufbar ist.
target_type	Ruft Typinformationen für das aufrufbare Objekt ab.

Operatoren

Name	Beschreibung
Operator nicht angegeben	Prüft, ob ein gespeichertes aufrufbares Objekt existiert.
operator()	Ruf ein aufrufbares Objekt auf.
operator=	Ersetzt das gespeicherte aufrufbare Objekt.

Zuweisen

Weist ein aufrufbares Objekt diesem Funktionsobjekt zu.

template <class Fx, class Alloc>
    void assign(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    void assign(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Parameter

_Func
Ein aufrufbares Objekt.

_Fnref
Ein Verweiswrapper, der ein aufrufbares Objekt enthält.

Ax
Ein Zuweisungsobjekt.

Hinweise

Die Memberfunktionen ersetzen jeweils das von *this gehaltene callable object durch ein aufrufbares Objekt, das als operand übergeben wurde. Beide weisen Speicher mit dem Allocator-Objekt Ax zu.

Funktion

Konstruiert einen Wrapper, der entweder leer ist oder ein aufrufbares Objekt eines willkürlichen Typs mit einer festen Signatur speichert.

function();
function(nullptr_t npc);
function(const function& right);
template <class Fx>
    function(Fx _Func);
template <class Fx>
    function(reference_wrapper<Fx> _Fnref);
template <class Fx, class Alloc>
    function(
        Fx _Func,
        const Alloc& Ax);

template <class Fx, class Alloc>
    function(
        reference_wrapper<Fx> _Fnref,
        const Alloc& Ax);

Parameter

right
Das zu kopierende Funktionsobjekt.

Fx
Der Typ des aufrufbaren Objekts.

_Func
Das zu umschließende Objekt.

Alloc
Der Zuweisungstyp.

Ax
Die Zuweisung.

_Fnref
Der zu umschließende aufrufbare Objektverweis.

Hinweise

Die ersten beiden Konstruktoren erstellt ein leeres function-Objekt. Die darauf folgenden drei Konstruktoren erstellen ein function-Objekt, das ein aufrufbares Objekt enthält, das als Operand übergeben wurde. Die letzten beiden Konstruktoren weisen dem Zuweisungsobjekt Ax Speicher zu.

Beispiel

// std__functional__function_function.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>
#include <vector>

int square(int val)
{
    return val * val;
}

class multiply_by
{
public:
    explicit multiply_by(const int n) : m_n(n) { }

    int operator()(const int x) const
    {
        return m_n * x;
    }

private:
    int m_n;
};

int main()
{
    typedef std::vector< std::function<int (int)> > vf_t;

    vf_t v;
    v.push_back(square);
    v.push_back(std::negate<int>());
    v.push_back(multiply_by(3));

    for (vf_t::const_iterator i = v.begin(); i != v.end(); ++i)
    {
        std::cout << (*i)(10) << std::endl;
    }

    std::function<int (int)> f = v[0];
    std::function<int (int)> g;

    if (f) {
        std::cout << "f is non-empty (correct)." << std::endl;
    } else {
        std::cout << "f is empty (can't happen)." << std::endl;
    }

    if (g) {
        std::cout << "g is non-empty (can't happen)." << std::endl;
    } else {
        std::cout << "g is empty (correct)." << std::endl;
    }

    return 0;
}

100
-10
30
f is non-empty (correct).
g is empty (correct).

Operator nicht angegeben

Prüft, ob ein gespeichertes aufrufbares Objekt existiert.

operator unspecified();

Hinweise

Der Operator gibt einen Wert zurück, der nur dann mit einem echten Wert konvertierbar bool ist, wenn das Objekt nicht leer ist. Damit können Sie prüfen, ob das Objekt leer ist.

Beispiel

// std__functional__function_operator_bool.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0;
    std::cout << std::boolalpha << "not empty == " << (bool)fn0 << std::endl;

    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "not empty == " << (bool)fn1 << std::endl;

    return (0);
    }

not empty == false
not empty == true

Operator()

Ruf ein aufrufbares Objekt auf.

result_type operator()(
    T1 t1,
    T2 t2, ...,
    TN tN);

Parameter

TN
Der Typ des n-ten Aufrufarguments.

Tn
Das n-te Aufrufargument.

Hinweise

Die Memberfunktion gibt INVOKE(fn, t1, t2, ..., tN, Ret) zurück, wenn fn das in *this gespeicherte Zielobjekt ist. Damit können Sie das umschlossene aufrufbare Objekt aufrufen.

Beispiel

// std__functional__function_operator_call.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3

operator =

Ersetzt das gespeicherte aufrufbare Objekt.

function& operator=(null_ptr_type npc);
function& operator=(const function& right);
template <class Fty>
    function& operator=(Fty fn);
template <class Fty>
    function& operator=(reference_wrapper<Fty> fnref);

Parameter

Npc
Eine NULL-Zeiger-Konstante.

right
Das zu kopierende Funktionsobjekt.

Fn
Das zu umschließende Objekt.

fnref
Der zu umschließende aufrufbare Objektverweis.

Hinweise

Die Operatoren ersetzen jeweils das von *this gehaltene aufrufbare Objekt durch ein aufrufbares Objekt, das als Operand übergeben wurde.

Beispiel

// std__functional__function_operator_as.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "val == " << fn0(3) << std::endl;

    std::function<int (int)> fn1;
    fn1 = 0;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;

    fn1 = neg;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    fn1 = fn0;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    fn1 = std::cref(fn1);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3
empty == true
empty == false
val == -3
empty == false
val == -3
empty == false
val == -3

Result_type

Der Rückgabetyp des gespeicherten aufrufbaren Objekts.

typedef Ret result_type;

Hinweise

Die Typedef stellt ein Synonym für den Typ Ret in der Aufrufsignatur der Vorlage dar. Damit können Sie den Rückgabetyp des umschlossenen aufrufbaren Objekts bestimmen.

Beispiel

// std__functional__function_result_type.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn1(neg);
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;

    std::function<int (int)>::result_type val = fn1(3);
    std::cout << "val == " << val << std::endl;

    return (0);
    }

empty == false
val == -3

swap

Tauscht zwei aufrufbare Objekte miteinander.

void swap(function& right);

Parameter

right
Das Funktionsobjekt, mit dem getauscht werden soll.

Hinweise

Die Memberfunktion vertauscht die Zielobjekte zwischen *this und rechts. Die Funktion führt dies in konstanter Zeit aus und löst keine Ausnahmen aus.

Beispiel

// std__functional__function_swap.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "val == " << fn0(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << std::endl;

    fn0.swap(fn1);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "val == " << fn1(3) << std::endl;

    return (0);
    }

empty == false
val == -3
empty == true

empty == true
empty == false
val == -3

target

Prüft, ob das gespeicherte aufrufbare Objekt wie festgelegt aufrufbar ist.

template <class Fty2>
    Fty2 *target();
template <class Fty2>
    const Fty2 *target() const;

Parameter

Fty2
Der zu überprüfende Typ des aufrufbaren Zielobjekts.

Hinweise

Der Typ Fty2 muss für die Argumenttypen T1, T2, ..., TN und den Rückgabetyp Retaufgerufen werden können. Wenn target_type() == typeid(Fty2), dann gibt die Membervorlagenfunktion die Adresse des Zielobjekts zurück; andernfalls gibt sie 0 zurück.

Ein Typ Fty2 kann für die Argumenttypen T1, T2, ..., TN und den Rückgabetyp Ret aufgerufen werden, wenn für lvalues von Typen bzwINVOKE(fn, t1, t2, ..., tN). für lvalues fn, t1, t2, ..., tN von Typen Fty2, T1, T2, ..., TNwohlgeformt ist und, wenn Ret nichtvoid, in Ret.

Beispiel

// std__functional__function_target.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    typedef int (*Myfun)(int);
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "no target == " << (fn0.target<Myfun>() == 0) << std::endl;

    Myfun *fptr = fn0.target<Myfun>();
    std::cout << "val == " << (*fptr)(3) << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "no target == " << (fn1.target<Myfun>() == 0) << std::endl;

    return (0);
    }

empty == false
no target == false
val == -3
empty == true
no target == true

target_type

Ruft Typinformationen für das aufrufbare Objekt ab.

const std::type_info& target_type() const;

Hinweise

Die Memberfunktion gibt typeid(void) zurück, wenn *this leer ist, andernfalls typeid(T), wobei T der Typ des Zielobjekts ist.

Beispiel

// std__functional__function_target_type.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>

int neg(int val)
    {
    return (-val);
    }

int main()
    {
    std::function<int (int)> fn0(neg);
    std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
    std::cout << "type == " << fn0.target_type().name() << std::endl;

    std::function<int (int)> fn1;
    std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
    std::cout << "type == " << fn1.target_type().name() << std::endl;

    return (0);
    }

empty == false
type == int (__cdecl*)(int)
empty == true
type == void

Teilen über

function-Klasse

Syntax

Parameter

Hinweise

Member

Konstruktoren

TypeDefs

Funktionen

Operatoren

Zuweisen

Parameter

Hinweise

Funktion

Parameter

Hinweise

Beispiel

Operator nicht angegeben

Hinweise

Beispiel

Operator()

Parameter

Hinweise

Beispiel

operator =

Parameter

Hinweise

Beispiel

Result_type

Hinweise

Beispiel

swap

Parameter

Hinweise

Beispiel

target

Parameter

Hinweise

Beispiel

target_type

Hinweise

Beispiel

Feedback

Feedback

Zusätzliche Ressourcen