<functional> -Funktionen

Diese Funktionen sind in C++11 veraltet und in C++17 entfernt:

bind1st
bind2nd
mem_fun
mem_fun_ref
ptr_fun

Diese Funktionen sind in C++17 veraltet:

not1
not2

bind

Bindet Argumente an ein aufrufbares Objekt.

template <class FT, class T1, class T2, ..., class TN>
    unspecified bind(FT fn, T1 t1, T2 t2, ..., TN tN);

template <class RTy, class FT, class T1, class T2, ..., class TN>
    unspecified bind(FT fn, T1 t1, T2 t2, ..., TN tN);

Parameter

FT
Der Typ des aufzurufenden Objekts. Beispielsweise der Typ der Funktion, des Funktionsobjekts, des Funktionszeigers/des Bezugs oder des Memberfunktionszeigers.

RTy
Der Rückgabetyp. Wenn angegeben, ist es der Rückgabetyp des gebundenen Anrufs. Andernfalls ist der Rückgabetyp der Rückgabetyp .FT

TN
Der Typ des n-ten Aufrufarguments.

fn
Das aufzurufende Objekt.

tN
Das n-te Aufrufargument.

Hinweise

Die Typen FT, T1, T2, ..., TN müssen kopierkonstruktierbar sein und INVOKE(fn, t1, ..., tN) ein gültiger Ausdruck für einige Werte w1, w2, ..., wNsein.

Die erste Vorlagenfunktion gibt einen weiterleitenden Aufrufwrapper g mit einem schwachen Ergebnistyp zurück. Die Auswirkung g(u1, u2, ..., uM) ist INVOKE(f, v1, v2, ..., vN, invoke_result<FT cv (V1, V2, ..., VN)>::type), wobei cv die CV-Qualifizierer und g die Werte und Typen der gebundenen Argumente v1, v2, ..., vN wie unten angegeben bestimmt werden. Damit binden Sie Argumente an aufrufbare Objekte, um aufrufbare Objekte mit einer angepassten Argumentliste zu erhalten.

Die zweite Vorlagenfunktion gibt einen weiterleitenden Aufrufwrapper g mit einem geschachtelten Typ result_type zurück, der ein Synonym für RTy darstellt. g(u1, u2, ..., uM) bewirkt INVOKE(f, v1, v2, ..., vN, RTy), wo cv der CV-Qualifizierer von g ist, und die Werte und Typen der gebundenen Argumente v1, v2, ..., vN wie unten beschrieben bestimmt werden. Damit binden Sie Argumente an aufrufbare Objekte, um aufrufbare Objekte mit einer angepassten Argumentliste und einem angegebenen Rückgabetypen zu erhalten.

Die Werte des gebundenen Arguments v1, v2, ..., vN und ihre entsprechenden Typen V1, V2, ..., VN hängen folgendermaßen vom Typ Ti des entsprechenden Arguments ti im Aufruf an bind und an die CV-Qualifiziererncv des Aufrufwrappers g ab:

Ist ti der Typreference_wrapper<T>, ist ti.get() das Argument vi und sein Typ Vi lautet T&;

Wenn der Wert des std::is_bind_expression<Ti>::value Arguments ist und sein Typ Vi lautet cv result_of<Ti (U1&, U2&, ..., UN&>::type;ti(u1, u2, ..., uM) vi true

Wenn der Wert j von std::is_placeholder<Ti>::value nicht null ist, ist uj das Argument vi und sein Typ Vi ist Uj&;

Andernfalls ist das Argument vi und sein Typ Vi ist Ti cv &.ti

Hat man beispielsweise eine Funktion f(int, int), gibt der Ausdruck bind(f, _1, 0) einen weiterleitenden Aufrufwrapper cw zurück, sodass cw(x)f(x, 0) aufruft. Der Ausdruck bind(f, 0, _1) gibt einen weiterleitenden Aufrufwrapper cw zurück, sodass cw(x)f(0, x) aufruft.

Die Anzahl der Argumente in einem Aufruf bind und das Argument fn muss der Anzahl der Argumente entsprechen, die an das aufrufbare Objekt fnübergeben werden können. Ist z. B bind(cos, 1.0) . richtig, und beides bind(cos) und bind(cos, _1, 0.0) sind falsch.

Die Anzahl von Argumenten in dem Funktionsaufruf an den Aufrufwrapper, der von bind zurückgegeben wurde, muss mindestens so hoch sein wie der höchste nummerierte Wert von is_placeholder<PH>::value für alle Platzhalterargumente in dem Aufruf an bind. Ist z. B. bind(cos, _2)(0.0, 1.0) richtig (und gibt cos(1.0)zurück) und bind(cos, _2)(0.0) ist falsch.

Beispiel

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

using namespace std::placeholders;

void square(double x)
{
    std::cout << x << "^2 == " << x * x << std::endl;
}

void product(double x, double y)
{
    std::cout << x << "*" << y << " == " << x * y << std::endl;
}

int main()
{
    double arg[] = { 1, 2, 3 };

    std::for_each(&arg[0], arg + 3, square);
    std::cout << std::endl;

    std::for_each(&arg[0], arg + 3, std::bind(product, _1, 2));
    std::cout << std::endl;

    std::for_each(&arg[0], arg + 3, std::bind(square, _1));

    return (0);
}

1^2 == 1
2^2 == 4
3^2 == 9

1*2 == 2
2*2 == 4
3*2 == 6

1^2 == 1
2^2 == 4
3^2 == 9

bind1st

Eine Hilfsvorlagenfunktion, die einen Adapter erstellt, um ein binäres Funktionsobjekt in ein unäres Funktionsobjekt zu konvertieren. Es bindet das erste Argument der binären Funktion an einen angegebenen Wert. Veraltet in C++11, entfernt in C++17.

template <class Operation, class Type>
    binder1st <Operation> bind1st (const Operation& func, const Type& left);

Parameter

func
Das binäre Funktionsobjekt, das in ein unäres Funktionsobjekt konvertiert werden soll.

left
Der Wert, an den das erste Argument des binären Funktionsobjekts gebunden werden soll.

Rückgabewert

Das unäre Funktionsobjekt, das aus der Bindung des ersten Arguments des binären Funktionsobjekts an den Wert leftresultiert.

Hinweise

Funktionsbinder sind eine Art Funktionsadapter. Da sie Funktionsobjekte zurückgeben, können sie in bestimmten Arten der Funktionskomposition verwendet werden, um kompliziertere und leistungsfähigere Ausdrücke zu erstellen.

Wenn func es sich um ein Objekt vom Typ Operation handelt und c eine Konstante ist, ist sie bind1st( func, c ) identisch mit dem binder1st Klassenkonstruktor binder1st<Operation>(func, c)und ist praktischer zu verwenden.

Beispiel

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

using namespace std;

// Creation of a user-defined function object
// that inherits from the unary_function base class
class greaterthan5: unary_function<int, bool>
{
public:
    result_type operator()(argument_type i)
    {
        return (result_type)(i > 5);
    }
};

int main()
{
    vector<int> v1;
    vector<int>::iterator Iter;

    int i;
    for (i = 0; i <= 5; i++)
    {
        v1.push_back(5 * i);
    }

    cout << "The vector v1 = ( " ;
    for (Iter = v1.begin(); Iter != v1.end(); Iter++)
        cout << *Iter << " ";
    cout << ")" << endl;

    // Count the number of integers > 10 in the vector
    vector<int>::iterator::difference_type result1a;
    result1a = count_if(v1.begin(), v1.end(), bind1st(less<int>(), 10));
    cout << "The number of elements in v1 greater than 10 is: "
         << result1a << "." << endl;

    // Compare: counting the number of integers > 5 in the vector
    // with a user defined function object
    vector<int>::iterator::difference_type result1b;
    result1b = count_if(v1.begin(), v1.end(), greaterthan5());
    cout << "The number of elements in v1 greater than 5 is: "
         << result1b << "." << endl;

    // Count the number of integers < 10 in the vector
    vector<int>::iterator::difference_type result2;
    result2 = count_if(v1.begin(), v1.end(), bind2nd(less<int>(), 10));
    cout << "The number of elements in v1 less than 10 is: "
         << result2 << "." << endl;
}

The vector v1 = ( 0 5 10 15 20 25 )
The number of elements in v1 greater than 10 is: 3.
The number of elements in v1 greater than 5 is: 4.
The number of elements in v1 less than 10 is: 2.

bind2nd

Eine Hilfsvorlagenfunktion, die einen Adapter erstellt, um ein binäres Funktionsobjekt in ein unäres Funktionsobjekt zu konvertieren. Es bindet das zweite Argument der binären Funktion an einen angegebenen Wert. Veraltet in C++11, entfernt in C++17.

template <class Operation, class Type>
    binder2nd <Operation> bind2nd(const Operation& func, const Type& right);

Parameter

func
Das binäre Funktionsobjekt, das in ein unäres Funktionsobjekt konvertiert werden soll.

right
Der Wert, an den das zweite Argument des binären Funktionsobjekts gebunden werden soll.

Rückgabewert

Das Ergebnis des unären Funktionsobjekts, das das zweite Argument des binären Funktionsobjekts anbindet.right

Hinweise

Funktionsbinder sind eine Art Funktionsadapter. Da sie Funktionsobjekte zurückgeben, können sie in bestimmten Arten der Funktionskomposition verwendet werden, um kompliziertere und leistungsfähigere Ausdrücke zu erstellen.

Wenn func es sich um ein Objekt vom Typ Operation handelt und c eine Konstante ist, ist sie bind2nd(func, c) identisch mit dem binder2nd Klassenkonstruktor binder2nd<Operation>(func, c)und ist praktischer zu verwenden.

Beispiel

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

using namespace std;

// Creation of a user-defined function object
// that inherits from the unary_function base class
class greaterthan15: unary_function<int, bool>
{
public:
    result_type operator()(argument_type i)
    {
        return (result_type)(i > 15);
    }
};

int main()
{
    vector<int> v1;
    vector<int>::iterator Iter;

    int i;
    for (i = 0; i <= 5; i++)
    {
        v1.push_back(5 * i);
    }

    cout << "The vector v1 = ( ";
    for (Iter = v1.begin(); Iter != v1.end(); Iter++)
        cout << *Iter << " ";
    cout << ")" << endl;

    // Count the number of integers > 10 in the vector
    vector<int>::iterator::difference_type result1a;
    result1a = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 10));
    cout << "The number of elements in v1 greater than 10 is: "
         << result1a << "." << endl;

    // Compare counting the number of integers > 15 in the vector
    // with a user-defined function object
    vector<int>::iterator::difference_type result1b;
    result1b = count_if(v1.begin(), v1.end(), greaterthan15());
    cout << "The number of elements in v1 greater than 15 is: "
         << result1b << "." << endl;

    // Count the number of integers < 10 in the vector
    vector<int>::iterator::difference_type result2;
    result2 = count_if(v1.begin(), v1.end(), bind1st(greater<int>(), 10));
    cout << "The number of elements in v1 less than 10 is: "
         << result2 << "." << endl;
}

The vector v1 = ( 0 5 10 15 20 25 )
The number of elements in v1 greater than 10 is: 3.
The number of elements in v1 greater than 15 is: 2.
The number of elements in v1 less than 10 is: 2.

bit_and

Ein vordefiniertes Funktionsobjekt, das einen bitweisen AND-Vorgang (binär operator&) für seine Argumente ausführt.

template <class Type = void>
struct bit_and : public binary_function<Type, Type, Type
{
    Type operator()(
    const Type& Left,
    const Type& Right) const;
};

// specialized transparent functor for operator&
template <>
struct bit_and<void>
{
    template <class T, class U>
    auto operator()(T&& Left, U&& Right) const  ->
        decltype(std::forward<T>(Left) & std::forward<U>(Right));
};

Parameter

Type, TU
Jeder Typ, der ein operator&-Element unterstützt, das Operanden angegebener oder abgeleiteter Typen akzeptiert.

Left
Der linke Operand des bitweisen AND-Vorgangs. Die nicht spezialisierte Vorlage besitzt ein lvalue-Verweisargument vom Typ Type. Die spezialisierte Vorlage vervollkommnet die Weiterleitung von lvalue und rvalue-Verweisargumenten des abgeleiteten Typs T.

Right
Der rechte Operand des bitweisen AND-Vorgangs. Die nicht spezialisierte Vorlage besitzt ein lvalue-Verweisargument vom Typ Type. Die spezialisierte Vorlage vervollkommnet die Weiterleitung von lvalue und rvalue-Verweisargumenten des abgeleiteten Typs U.

Rückgabewert

Das Ergebnis von Left & Right. Die spezialisierte Vorlage vervollkommnet die Weiterleitung des Ergebnisses mit dem von operator& zurückgegebenen Typs.

Hinweise

Das bit_and-Funktionselement wird auf Ganzzahltypen für die grundlegenden Datentypen oder benutzerdefinierte Typen beschränkt, die das binäre operator&-Element implementieren.

bit_not

Ein vordefiniertes Funktionsobjekt, das einen bitweisen Komplementvorgang (NOT operator~) für das Argument ausführt. In C++14 hinzugefügt.

template <class Type = void>
struct bit_not : public unary_function<Type, Type>
{
    Type operator()(const Type& Right) const;
};

// specialized transparent functor for operator~
template <>
struct bit_not<void>
{
    template <class Type>
    auto operator()(Type&& Right) const -> decltype(~std::forward<Type>(Right));
};

Parameter

Type
Ein Typ, der ein unäres operator~-Element unterstützt.

Right
Der Operand des bitweisen komplementären Vorgangs. Die nicht spezialisierte Vorlage besitzt ein lvalue-Verweisargument vom Typ Type. Die spezialisierte Vorlage vervollkommnet die Weiterleitung von eines lvalue- oder eines rvalue-Verweisarguments des abgeleiteten Typs Type.

Rückgabewert

Das Ergebnis von ~ Right. Die spezialisierte Vorlage vervollkommnet die Weiterleitung des Ergebnisses mit dem von operator~ zurückgegebenen Typs.

Hinweise

Das bit_not-Funktionselement wird auf Ganzzahltypen für die grundlegenden Datentypen oder benutzerdefinierte Typen beschränkt, die das binäre operator~-Element implementieren.

bit_or

Ein vordefiniertes Funktionsobjekt, das einen bitweisen OR-Vorgang (operator|) für seine Argumente ausführt.

template <class Type = void>
struct bit_or : public binary_function<Type, Type, Type>
{
    Type operator()(
    const Type& Left,
    const Type& Right) const;
};

// specialized transparent functor for operator|
template <>
struct bit_or<void>
{
    template <class T, class U>
    auto operator()(T&& Left, U&& Right) const
        -> decltype(std::forward<T>(Left) | std::forward<U>(Right));
};

Parameter

Type, TU
Jeder Typ, der ein operator|-Element unterstützt, das Operanden angegebener oder abgeleiteter Typen akzeptiert.

Left
Der linke Operand des bitweisen OR-Vorgangs. Die nicht spezialisierte Vorlage besitzt ein lvalue-Verweisargument vom Typ Type. Die spezialisierte Vorlage vervollkommnet die Weiterleitung von lvalue und rvalue-Verweisargumenten des abgeleiteten Typs T.

Right
Der rechte Operand des bitweisen OR-Vorgangs. Die nicht spezialisierte Vorlage besitzt ein lvalue-Verweisargument vom Typ Type. Die spezialisierte Vorlage vervollkommnet die Weiterleitung von lvalue und rvalue-Verweisargumenten des abgeleiteten Typs U.

Rückgabewert

Das Ergebnis von Left | Right. Die spezialisierte Vorlage vervollkommnet die Weiterleitung des Ergebnisses mit dem von operator| zurückgegebenen Typs.

Hinweise

Das bit_or-Funktionselement wird auf Ganzzahltypen für die grundlegenden Datentypen oder benutzerdefinierte Typen beschränkt, die operator| implementieren.

bit_xor

Ein vordefiniertes Funktionsobjekt, das einen bitweisen XOR-Vorgang (binär operator^) für seine Argumente ausführt.

template <class Type = void>
struct bit_xor : public binary_function<Type, Type, Type>
{
    Type operator()(
    const Type& Left,
    const Type& Right) const;
};

// specialized transparent functor for operator^
template <>
struct bit_xor<void>
{
    template <class T, class U>
    auto operator()(T&& Left, U&& Right) const
        -> decltype(std::forward<T>(Left) ^ std::forward<U>(Right));
};

Parameter

Type, TU
Jeder Typ, der ein operator^-Element unterstützt, das Operanden angegebener oder abgeleiteter Typen akzeptiert.

Left
Der linke Operand des bitweisen XOR-Vorgangs. Die nicht spezialisierte Vorlage besitzt ein lvalue-Verweisargument vom Typ Type. Die spezialisierte Vorlage vervollkommnet die Weiterleitung von lvalue und rvalue-Verweisargumenten des abgeleiteten Typs T.

Right
Der rechte Operand des bitweisen XOR-Vorgangs. Die nicht spezialisierte Vorlage besitzt ein lvalue-Verweisargument vom Typ Type. Die spezialisierte Vorlage vervollkommnet die Weiterleitung von lvalue und rvalue-Verweisargumenten des abgeleiteten Typs U.

Rückgabewert

Das Ergebnis von Left ^ Right. Die spezialisierte Vorlage vervollkommnet die Weiterleitung des Ergebnisses mit dem von operator^ zurückgegebenen Typs.

Hinweise

Das bit_xor-Funktionselement wird auf Ganzzahltypen für die grundlegenden Datentypen oder benutzerdefinierte Typen beschränkt, die das binäre operator^-Element implementieren.

cref

Erstellt ein konstantes reference_wrapper-Element aus einem Argument.

template <class Ty>
reference_wrapper<const Ty> cref(const Ty& arg);

template <class Ty>
reference_wrapper<const Ty> cref(const reference_wrapper<Ty>& arg);

Parameter

Ty
Der Typ des zu umschließenden Arguments.

arg
Das zu umschließende Argument.

Hinweise

Diese erste Funktion gibt reference_wrapper<const Ty>(arg.get()) zurück. Damit können Sie einen const-Verweis umschließen. Die zweite Funktion gibt reference_wrapper<const Ty>(arg) zurück. Damit können Sie einen bereits umschlossenen Verweis erneut als const-Verweis umschließen.

Beispiel

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

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

int main()
{
    int i = 1;

    std::cout << "i = " << i << std::endl;
    std::cout << "cref(i) = " << std::cref(i) << std::endl;
    std::cout << "cref(neg)(i) = "
        << std::cref(&neg)(i) << std::endl;

    return (0);
}

i = 1
cref(i) = 1
cref(neg)(i) = -1

invoke

Ruft jedes aufrufbare Objekt mit den angegebenen Argumenten auf. In C++17 hinzugefügt.

template <class Callable, class... Args>
invoke_result_t<Callable, Args...>
    invoke(Callable&& fn, Args&&... args) noexcept(/* specification */);

Parameter

Callable
Der Typ des aufzurufenden Objekts.

Args
Die Typen der Aufrufargumente.

fn
Das aufzurufende Objekt.

args
Den Aufrufargumente.

specification
Die noexcept Spezifikation std::is_nothrow_invocable_v<Callable, Args>).

Hinweise

Ruft das aufrufbare Objekt fn mithilfe der Parameter argsauf. Effektiv bedeutet INVOKE(std::forward<Callable>(fn), std::forward<Args>(args)...)die Pseudofunktion INVOKE(f, t1, t2, ..., tN) eines der folgenden Dinge:

• (t1.*f)(t2, ..., tN), wenn f ein Zeiger auf eine Memberfunktion der Klasse T und t1 ist, ist ein Objekt vom Typ T oder ein Verweis auf ein Objekt vom Typ T oder ein Verweis auf ein Objekt eines Typs, der von T abgeleitet wird. Das heißt, wenn std::is_base_of<T, std::decay_t<decltype(t1)>>::value es wahr ist.

• (t1.get().*f)(t2, ..., tN) wenn f ein Zeiger auf die Memberfunktion der Klasse T ist und std::decay_t<decltype(t1)> eine Spezialisierung von std::reference_wrapper.

• ((*t1).*f)(t2, ..., tN) ist f ein Zeiger auf die Memberfunktion der Klasse T und t1 nicht einer der vorherigen Typen.

• t1.*f, wenn N == 1 und f ein Zeiger auf Memberdaten einer Klasse T und t1 ist, ist ein Objekt vom Typ T oder ein Verweis auf ein Objekt vom Typ T oder ein Verweis auf ein Objekt eines Typs, der von T abgeleitet wird. Das heißt, wenn std::is_base_of<T, std::decay_t<decltype(t1)>>::value es wahr ist.

• t1.get().*f wenn N == 1 und f ist ein Zeiger auf Memberdaten einer Klasse T und std::decay_t<decltype(t1)> ist eine Spezialisierung von std::reference_wrapper.

• (*t1).*f wenn N == 1 ist und f ein Zeiger auf Memberdaten einer Klasse T ist und t1 keiner der vorherigen Typen ist.

• In allen anderen Fällen f(t1, t2, ..., tN).

Informationen zum Ergebnistyp eines aufrufbaren Objekts finden Sie unter invoke_result. Prädikate für aufrufbare Typen finden Sie unter is_invocable, is_invocable_r, is_nothrow_invocable, is_nothrow_invocable_r Klassen.

Beispiel

// functional_invoke.cpp
// compile using: cl /EHsc /std:c++17 functional_invoke.cpp
#include <functional>
#include <iostream>

struct Demo
{
    int n_;

    Demo(int const n) : n_{n} {}

    void operator()( int const i, int const j ) const
    {
        std::cout << "Demo operator( " << i << ", "
            << j << " ) is " << i * j << "\n";
    }

    void difference( int const i ) const
    {
        std::cout << "Demo.difference( " << i << " ) is "
            << n_ - i << "\n";
    }
};

void divisible_by_3(int const i)
{
    std::cout << i << ( i % 3 == 0 ? " is" : " isn't" )
        << " divisible by 3.\n";
}

int main()
{
    Demo d{ 42 };
    Demo * pd{ &d };
    auto pmf = &Demo::difference;
    auto pmd = &Demo::n_;

    // Invoke a function object, like calling d( 3, -7 )
    std::invoke( d, 3, -7 );

    // Invoke a member function, like calling
    // d.difference( 29 ) or (d.*pmf)( 29 )
    std::invoke( &Demo::difference, d, 29 );
    std::invoke( pmf, pd, 13 );

    // Invoke a data member, like access to d.n_ or d.*pmd
    std::cout << "d.n_: " << std::invoke( &Demo::n_, d ) << "\n";
    std::cout << "pd->n_: " << std::invoke( pmd, pd ) << "\n";

    // Invoke a stand-alone (free) function
    std::invoke( divisible_by_3, 42 );

    // Invoke a lambda
    auto divisible_by_7 = []( int const i )
    {
        std::cout << i << ( i % 7 == 0 ? " is" : " isn't" )
            << " divisible by 7.\n";
    };
    std::invoke( divisible_by_7, 42 );
}

Demo operator( 3, -7 ) is -21
Demo.difference( 29 ) is 13
Demo.difference( 13 ) is 29
d.n_: 42
pd->n_: 42
42 is divisible by 3.
42 is divisible by 7.

mem_fn

Generiert einen einfachen Aufrufwrapper.

template <class RTy, class Ty>
unspecified mem_fn(RTy Ty::*pm);

Parameter

RTy
Der Rückgabetyp der umschlossenen Funktion.

Ty
Der Typ des Memberfunktionszeigers.

Hinweise

Die Vorlagenfunktion gibt einen einfachen Aufrufwrapper cwmit einem schwachen Ergebnistyp zurück, sodass der Ausdruck cw(t, a2, ..., aN) identisch INVOKE(pm, t, a2, ..., aN)ist. Es löst keine Ausnahmen aus.

Der zurückgegebene Aufrufwrapper wird von std::unary_function<cv Ty*, RTy> (und das Definieren des geschachtelten Typs result_type als Synonym für RTy und den geschachtelten Typ argument_type als Synonym für cv Ty*) nur abgeleitet, wenn der Typ Ty ein Zeiger auf die Memberfunktion mit cv-Qualifizierer cv ist, der keine Argumente akzeptiert.

Der zurückgegebene Aufrufwrapper wird abgeleitet von std::binary_function<cv Ty*, T2, RTy> (und definiert den geschachtelten Typ result_type als Synonym für RTy, den geschachtelten Typ first argument_type als Synonym für cv Ty*) und den geschachtelten Typ als Synonym für T2) nur, wenn der Typ Ty second argument_type ein Zeiger auf die Memberfunktion mit cv-Qualifizierer cv ist, der ein Argument vom Typ T2akzeptiert.

Beispiel

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

class Funs
{
public:
    void square(double x)
    {
        std::cout << x << "^2 == " << x * x << std::endl;
    }

    void product(double x, double y)
    {
        std::cout << x << "*" << y << " == " << x * y << std::endl;
    }
};

int main()
{
    Funs funs;

    std::mem_fn(&Funs::square)(funs, 3.0);
    std::mem_fn(&Funs::product)(funs, 3.0, 2.0);

    return (0);
}

3^2 == 9
3*2 == 6

mem_fun

Hilfevorlagenfunktionen, die verwendet werden, um Funktionsobjektadapter für Memberfunktionen zu konstruieren, wenn Sie mit Zeigerargumenten initialisiert werden. Veraltet in C++11 für mem_fn und bind, und entfernt in C++17.

template <class Result, class Type>
mem_fun_t<Result, Type> mem_fun (Result(Type::* pMem)());

template <class Result, class Type, class Arg>
mem_fun1_t<Result, Type, Arg> mem_fun(Result (Type::* pMem)(Arg));

template <class Result, class Type>
const_mem_fun_t<Result, Type> mem_fun(Result (Type::* pMem)() const);

template <class Result, class Type, class Arg>
const_mem_fun1_t<Result, Type, Arg> mem_fun(Result (Type::* pMem)(Arg) const);

Parameter

pMem
Ein Zeiger auf die Memberfunktion der Klasse Type, die in ein Funktionsobjekt konvertiert werden soll.

Rückgabewert

Ein const oder ein Nicht-Const-Funktionsobjekt vom Typ mem_fun_t oder mem_fun1_t.

Beispiel

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

using namespace std;

class StoreVals
{
    int val;
public:
    StoreVals() { val = 0; }
    StoreVals(int j) { val = j; }

    bool display() { cout << val << " "; return true; }
    int squareval() { val *= val; return val; }
    int lessconst(int k) {val -= k; return val; }
};

int main( )
{
    vector<StoreVals *> v1;

    StoreVals sv1(5);
    v1.push_back(&sv1);
    StoreVals sv2(10);
    v1.push_back(&sv2);
    StoreVals sv3(15);
    v1.push_back(&sv3);
    StoreVals sv4(20);
    v1.push_back(&sv4);
    StoreVals sv5(25);
    v1.push_back(&sv5);

    cout << "The original values stored are: " ;
    for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
    cout << endl;

    // Use of mem_fun calling member function through a pointer
    // square each value in the vector using squareval ()
    for_each(v1.begin(), v1.end(), mem_fun<int, StoreVals>(&StoreVals::squareval));
    cout << "The squared values are: " ;
    for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
    cout << endl;

    // Use of mem_fun1 calling member function through a pointer
    // subtract 5 from each value in the vector using lessconst ()
    for_each(v1.begin(), v1.end(),
        bind2nd (mem_fun1<int, StoreVals,int>(&StoreVals::lessconst), 5));
    cout << "The squared values less 5 are: " ;
    for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
    cout << endl;
}

mem_fun_ref

Hilfevorlagenfunktionen, die verwendet werden, um Funktionsobjektadapter für Memberfunktionen zu konstruieren, indem Sie mit Verweisargumenten initialisiert werden. Veraltet in C++11, entfernt in C++17.

template <class Result, class Type>
mem_fun_ref_t<Result, Type> mem_fun_ref(Result (Type::* pMem)());

template <class Result, class Type, class Arg>
mem_fun1_ref_t<Result, Type, Arg> mem_fun_ref(Result (Type::* pMem)(Arg));

template <class Result, class Type>
const_mem_fun_ref_t<Result, Type> mem_fun_ref(Result Type::* pMem)() const);

template <class Result, class Type, class Arg>
const_mem_fun1_ref_t<Result, Type, Arg> mem_fun_ref(Result (T::* pMem)(Arg) const);

Parameter

pMem
Ein Zeiger auf die Memberfunktion der Klasse Type, die in ein Funktionsobjekt konvertiert werden soll.

Rückgabewert

Ein const- oder non_const-Funktionsobjekt des Typs mem_fun_ref_t oder mem_fun1_ref_t.

Beispiel

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

using namespace std;

class NumVals
{
   int val;
   public:
   NumVals ( ) { val = 0; }
   NumVals ( int j ) { val = j; }

   bool display ( ) { cout << val << " "; return true; }
   bool isEven ( ) { return ( bool )  !( val %2 ); }
   bool isPrime( )
   {
      if (val < 2) { return true; }
      for (int i = 2; i <= val / i; ++i)
      {
         if (val % i == 0) { return false; }
      }
      return true;
   }
};

int main( )
{
   vector <NumVals> v1 ( 13 ), v2 ( 13 );
   vector <NumVals>::iterator v1_Iter, v2_Iter;
   int i, k;

   for ( i = 0; i < 13; i++ ) v1 [ i ] = NumVals ( i+1 );
   for ( k = 0; k < 13; k++ ) v2 [ k ] = NumVals ( k+1 );

   cout << "The original values stored in v1 are: " ;
   for_each( v1.begin( ), v1.end( ),
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;

   // Use of mem_fun_ref calling member function through a reference
   // remove the primes in the vector using isPrime ( )
   v1_Iter = remove_if ( v1.begin( ),  v1.end( ),
      mem_fun_ref ( &NumVals::isPrime ) );
   cout << "With the primes removed, the remaining values in v1 are: " ;
   for_each( v1.begin( ), v1_Iter,
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;

   cout << "The original values stored in v2 are: " ;
   for_each( v2.begin( ), v2.end( ),
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;

   // Use of mem_fun_ref calling member function through a reference
   // remove the even numbers in the vector v2 using isEven ( )
   v2_Iter = remove_if ( v2.begin( ),  v2.end( ),
      mem_fun_ref ( &NumVals::isEven ) );
   cout << "With the even numbers removed, the remaining values are: " ;
   for_each( v2.begin( ),  v2_Iter,
   mem_fun_ref ( &NumVals::display ) );
   cout << endl;
}

The original values stored in v1 are: 1 2 3 4 5 6 7 8 9 10 11 12 13
With the primes removed, the remaining values in v1 are: 4 6 8 9 10 12
The original values stored in v2 are: 1 2 3 4 5 6 7 8 9 10 11 12 13
With the even numbers removed, the remaining values are: 1 3 5 7 9 11 13

not1

Gibt das Komplement eines unären Prädikats zurück. Veraltet für not_fn C++17.

template <class UnaryPredicate>
unary_negate<UnaryPredicate> not1(const UnaryPredicate& predicate);

Parameter

predicate
Das zu negierende unäre Prädikat.

Rückgabewert

Ein unäres Prädikat, das die Negation des modifizierten unären Prädikats ist.

Hinweise

Wenn ein Prädikat unary_negate aus einem unären Prädikat predicate(x)konstruiert wird, wird es zurückgegeben !predicate(x).

Beispiel

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

using namespace std;

int main()
{
    vector<int> v1;
    vector<int>::iterator Iter;

    int i;
    for (i = 0; i <= 7; i++)
    {
        v1.push_back(5 * i);
    }

    cout << "The vector v1 = ( ";
    for (Iter = v1.begin(); Iter != v1.end(); Iter++)
        cout << *Iter << " ";
    cout << ")" << endl;

    vector<int>::iterator::difference_type result1;
    // Count the elements greater than 10
    result1 = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 10));
    cout << "The number of elements in v1 greater than 10 is: "
         << result1 << "." << endl;

    vector<int>::iterator::difference_type result2;
    // Use the negator to count the elements less than or equal to 10
    result2 = count_if(v1.begin(), v1.end(),
        not1(bind2nd(greater<int>(), 10)));

    cout << "The number of elements in v1 not greater than 10 is: "
         << result2 << "." << endl;
}

The vector v1 = ( 0 5 10 15 20 25 30 35 )
The number of elements in v1 greater than 10 is: 5.
The number of elements in v1 not greater than 10 is: 3.

not2

Gibt das Komplement eines binären Prädikats zurück. Veraltet für not_fn C++17.

template <class BinaryPredicate>
binary_negate<BinaryPredicate> not2(const BinaryPredicate& func);

Parameter

func
Das zu negierende binäre Prädikat.

Rückgabewert

Ein binäres Prädikat, das die Negation des modifizierten binären Prädikats ist.

Hinweise

Wenn ein Prädikat binary_negate aus einem binären Prädikat binary_predicate(x, y)erstellt wird, wird es zurückgegeben !binary_predicate(x, y).

Beispiel

// functional_not2.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1;

   int i;
   v1.push_back( 6262 );
   v1.push_back( 6262 );
   for ( i = 0 ; i < 5 ; i++ )
   {
      v1.push_back( rand( ) );
   }

   cout << "Original vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To sort in ascending order,
   // use default binary predicate less<int>( )
   sort( v1.begin( ), v1.end( ) );
   cout << "Sorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;

   // To sort in descending order,
   // use the binary_negate helper function not2
   sort( v1.begin( ), v1.end( ), not2(less<int>( ) ) );
   cout << "Resorted vector v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")" << endl;
}

Original vector v1 = ( 6262 6262 41 18467 6334 26500 19169 )
Sorted vector v1 = ( 41 6262 6262 6334 18467 19169 26500 )
Resorted vector v1 = ( 26500 19169 18467 6334 6262 6262 41 )

not_fn

Die not_fn Funktionsvorlage verwendet ein aufrufbares Objekt und gibt ein aufrufbares Objekt zurück. Wenn das zurückgegebene aufrufbare Objekt später mit einigen Argumenten aufgerufen wird, übergibt es sie an das ursprüngliche aufrufbare Objekt und negiert das Ergebnis logisch. Es behält das Verhalten der Konstantenqualifizierung und wertkategorie des umschlossenen aufrufbaren Objekts bei. not_fn ist neu in C++17 und ersetzt die veralteten std::not1, , std::not2, std::unary_negateund std::binary_negate.

template <class Callable>
/* unspecified */ not_fn(Callable&& func);

Parameter

func
Ein aufrufbares Objekt, das zum Erstellen des Umleitungsaufrufwrappers verwendet wird.

Hinweise

Die Vorlagenfunktion gibt einen Aufrufwrapper wie return call_wrapper(std::forward<Callable>(func)), basierend auf dieser nur expositionsgeschützten Klasse, zurück:

class call_wrapper
{
   using FD = decay_t<Callable>;
   explicit call_wrapper(Callable&& func);

public:
   call_wrapper(call_wrapper&&) = default;
   call_wrapper(call_wrapper const&) = default;

   template<class... Args>
     auto operator()(Args&&...) & -> decltype(!declval<invoke_result_t<FD&(Args...)>>());

   template<class... Args>
     auto operator()(Args&&...) const& -> decltype(!declval<invoke_result_t<FD const&(Args...)>>());

   template<class... Args>
     auto operator()(Args&&...) && -> decltype(!declval<invoke_result_t<FD(Args...)>>());

   template<class... Args>
     auto operator()(Args&&...) const&& -> decltype(!declval<invoke_result_t<FD const(Args...)>>());

private:
  FD fd;
};

Der explizite Konstruktor für das aufrufbare Objekt func erfordert Typ std::decay_t<Callable> , um die Anforderungen von MoveConstructible, und is_constructible_v<FD, Callable> muss wahr sein. Es initialisiert das umschlossene aufrufbare Objekt fd aus std::forward<Callable>(func)und löst jede Ausnahme aus, die fddurch die Konstruktion ausgelöst wird.

Der Wrapper macht Anrufoperatoren verfügbar, die durch "lvalue" oder "rvalue reference category" und "const qualification" unterschieden werden, wie hier gezeigt:

template<class... Args> auto operator()(Args&&... args) & -> decltype(!declval<invoke_result_t<FD&(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const& -> decltype(!declval<invoke_result_t<FD const&(Args...)>>());
template<class... Args> auto operator()(Args&&... args) && -> decltype(!declval<invoke_result_t<FD(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const&& -> decltype(!declval<invoke_result_t<FD const(Args...)>>());

Die ersten beiden sind identisch mit return !std::invoke(fd, std::forward<Args>(args)...). Die zweiten beiden sind identisch mit return !std::invoke(std::move(fd), std::forward<Args>(args)...).

Beispiel

// functional_not_fn_.cpp
// compile with: /EHsc /std:c++17
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>

int main()
{
    std::vector<int> v1 = { 99, 6264, 41, 18467, 6334, 26500, 19169 };
    auto divisible_by_3 = [](int i){ return i % 3 == 0; };

    std::cout << "Vector v1 = ( " ;
    for (const auto& item : v1)
    {
        std::cout << item << " ";
    }
    std::cout << ")" << std::endl;

    // Count the number of vector elements divisible by 3.
    int divisible =
        std::count_if(v1.begin(), v1.end(), divisible_by_3);
    std::cout << "Elements divisible by three: "
        << divisible << std::endl;

    // Count the number of vector elements not divisible by 3.
    int not_divisible =
        std::count_if(v1.begin(), v1.end(), std::not_fn(divisible_by_3));
    std::cout << "Elements not divisible by three: "
        << not_divisible << std::endl;
}

Vector v1 = ( 99 6264 41 18467 6334 26500 19169 )
Elements divisible by three: 2
Elements not divisible by three: 5

ptr_fun

Hilfevorlagenfunktionen, die verwendet werden, um die jeweiligen unären und binären Funktionszeiger in die unären und binären anwendbaren Funktionen zu konvertieren. Veraltet in C++11, entfernt in C++17.

template <class Arg, class Result>
pointer_to_unary_function<Arg, Result, Result (*)(Arg)> ptr_fun(Result (*pfunc)(Arg));

template <class Arg1, class Arg2, class Result>
pointer_to_binary_function<Arg1, Arg2, Result, Result (*)(Arg1, Arg2)> ptr_fun(Result (*pfunc)(Arg1, Arg2));

Parameter

pfunc
Der unäre oder binäre Funktionszeiger, der in eine anwendbare Funktion konvertiert werden soll.

Rückgabewert

Die erste Vorlagenfunktion gibt die unäre Funktion pointer_to_unary_function<Arg, (* pfunc) zurück. Result>

Die zweite Vorlagenfunktion gibt binäre Funktion pointer_to_binary_functionArg1<, Arg2, (* Result>) zurück. pfunc

Hinweise

Ein Funktionszeiger ist ein Funktionsobjekt. Es kann an jeden Algorithmus übergeben werden, der eine Funktion als Parameter erwartet, aber es ist nicht anpassbar. Informationen zu den geschachtelten Typen sind erforderlich, um ihn beispielsweise mit einem Adapter zu verwenden, um einen Wert an ihn zu binden oder ihn zu verwerfen. Durch die Konvertierung von unären und binären Funktionszeigern mithilfe der Hilfsfunktion ptr_fun können die Funktionsadapter mit unären und binären Funktionszeigern arbeiten.

Beispiel

// functional_ptr_fun.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <cstring>
#include <iostream>

int main( )
{
    using namespace std;
    vector <char*> v1;
    vector <char*>::iterator Iter1, RIter;

    v1.push_back ( "Open" );
    v1.push_back ( "up" );
    v1.push_back ( "the" );
    v1.push_back ( "opalescent" );
    v1.push_back ( "gates" );

    cout << "Original sequence contains: " ;
    for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; ++Iter1 )
        cout << *Iter1 << " ";
    cout << endl;

    // To search the sequence for "opalescent"
    // use a pointer_to_function conversion
    RIter = find_if( v1.begin( ), v1.end( ),
        not1 ( bind2nd (ptr_fun ( strcmp ), "opalescent" ) ) );

    if ( RIter != v1.end( ) )  
    {
        cout << "Found a match: " 
            << *RIter << endl;
    }
}

ref

Konstruiert ein reference_wrapper aus einem Argument.

template <class Ty>
    reference_wrapper<Ty> ref(Ty& arg);

template <class Ty>
    reference_wrapper<Ty> ref(reference_wrapper<Ty>& arg);

Rückgabewert

Ein Verweis auf ein arg; insbesondere reference_wrapper<Ty>(arg).

Beispiel

Im folgenden Beispiel werden zwei Funktionen definiert: eine, die an eine Zeichenfolgenvariable gebunden ist, die andere, die an einen Verweis der Zeichenfolgenvariablen gebunden ist, der durch einen Aufruf von refberechnet wurde. Wenn sich der Wert der Variablen ändert, verwendet die erste Funktion weiterhin den alten Wert, und die zweite Version verwendet den neuen Wert.

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>
#include <vector>
using namespace std;
using namespace std;
using namespace std::placeholders;

bool shorter_than(const string& l, const string& r)
{
    return l.size() < r.size();
}

int main()
{
    vector<string> v_original;
    v_original.push_back("tiger");
    v_original.push_back("cat");
    v_original.push_back("lion");
    v_original.push_back("cougar");

    copy(v_original.begin(), v_original.end(), ostream_iterator<string>(cout, " "));
    cout << endl;

    string s("meow");

    function<bool (const string&)> f = bind(shorter_than, _1, s);
    function<bool (const string&)> f_ref = bind(shorter_than, _1, ref(s));

    vector<string> v;

    // Remove elements that are shorter than s ("meow")

    v = v_original;
    v.erase(remove_if(v.begin(), v.end(), f), v.end());

    copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
    cout << endl;

    // Now change the value of s.
    // f_ref, which is bound to ref(s), will use the
    // new value, while f is still bound to the old value.

    s = "kitty";

    // Remove elements that are shorter than "meow" (f is bound to old value of s)

    v = v_original;
    v.erase(remove_if(v.begin(), v.end(), f), v.end());

    copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
    cout << endl;

    // Remove elements that are shorter than "kitty" (f_ref is bound to ref(s))

    v = v_original;
    v.erase(remove_if(v.begin(), v.end(), f_ref), v.end());

    copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
    cout << endl;
}

tiger cat lion cougar
tiger lion cougar
tiger lion cougar
tiger cougar

swap

Tauscht zwei function-Objekte.

template <class FT>
    void swap(function<FT>& f1, function<FT>& f2);

Parameter

FT
Der vom Funktionsobjekt gesteuerte Typ.

f1
Das erste Funktionsobjekt.

f2
Das zweite Funktionsobjekt.

Hinweise

Die Funktion gibt f1.swap(f2) zurück.

Beispiel

// std__functional__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;

    swap(fn0, 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