Namespaces
Variants

std:: mem_fn

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* )
Definiert im Header <functional>
template < class M, class T >
/* unspecified */ mem_fn ( M T :: * pm ) noexcept ;
(seit C++11)
(constexpr seit C++20)

Funktionsvorlage std::mem_fn erzeugt Wrapper-Objekte für Zeiger auf Elemente, die einen Zeiger auf Element speichern, kopieren und aufrufen können. Sowohl Referenzen als auch Zeiger (einschließlich intelligenter Zeiger) auf ein Objekt können beim Aufruf von std::mem_fn verwendet werden.

Inhaltsverzeichnis

Parameter

pm - Zeiger auf Element, das gekapselt werden soll

Rückgabewert

std::mem_fn gibt einen Aufruf-Wrapper fn eines nicht näher spezifizierten Typs zurück, der die folgenden Member besitzt:

std::mem_fn Rückgabetyp

Member-Typen

Typ Definition
result_type (veraltet in C++17) Der Rückgabetyp von pm , falls pm ein Zeiger auf eine Member-Funktion ist; nicht definiert für Zeiger auf Member-Objekte
argument_type (veraltet in C++17) T* , möglicherweise cv-qualifiziert, falls pm ein Zeiger auf eine Member-Funktion ohne Argumente ist
first_argument_type (veraltet in C++17) T* , falls pm ein Zeiger auf eine Member-Funktion mit einem Argument ist
second_argument_type (veraltet in C++17) T1 , falls pm ein Zeiger auf eine Member-Funktion mit einem Argument vom Typ T1 ist
(bis C++20)

Member-Funktion

template < class ... Args >

/* siehe unten */ operator ( ) ( Args && ... args ) /* cvref-Qualifizierer */

noexcept ( /* siehe unten */ ) ;
(constexpr seit C++20)

Der Ausdruck fn ( args ) ist äquivalent zu INVOKE ( pmd, args ) , wobei pmd das von fn gehaltene Callable -Objekt ist, vom Typ M T::* und direkt-nicht-Listen-initialisiert mit pm .

Somit ist der Rückgabetyp von operator ( ) std:: result_of < decltype ( pm ) ( Args && ... ) > :: type oder äquivalent std:: invoke_result_t < decltype ( pm ) , Args && ... > , und der Wert in der noexcept -Spezifikation ist gleich std:: is_nothrow_invocable_v < decltype ( pm ) , Args && ... > ) (seit C++17) .

Jedes Argument in args wird perfekt weitergeleitet, wie durch std:: forward < Args > ( args ) ... .

Beispiel

Verwenden Sie std::mem_fn , um eine Memberfunktion und ein Memberobjekt zu speichern und auszuführen:

Diesen Code ausführen 
#include <functional>
#include <iostream>
#include <memory>
struct Foo
{
    void display_greeting()
    {
        std::cout << "Hello, world.\n";
    }
    void display_number(int i)
    {
        std::cout << "number: " << i << '\n';
    }
    int add_xy(int x, int y)
    {
        return data + x + y;
    }
    template<typename... Args> int add_many(Args... args)
    {
        return data + (args + ...);
    }
    auto add_them(auto... args) // C++20 required
    {
        return data + (args + ...);
    }
    int data = 7;
};
int main()
{
    auto f = Foo{};
    auto greet = std::mem_fn(&Foo::display_greeting);
    greet(f);
    auto print_num = std::mem_fn(&Foo::display_number);
    print_num(f, 42);
    auto access_data = std::mem_fn(&Foo::data);
    std::cout << "data: " << access_data(f) << '\n';
    auto add_xy = std::mem_fn(&Foo::add_xy);
    std::cout << "add_xy: " << add_xy(f, 1, 2) << '\n';
    auto u = std::make_unique<Foo>();
    std::cout << "access_data(u): " << access_data(u) << '\n';
    std::cout << "add_xy(u, 1, 2): " << add_xy(u, 1, 2) << '\n';
    auto add_many = std::mem_fn(&Foo::add_many<short, int, long>);
    std::cout << "add_many(u, ...): " << add_many(u, 1, 2, 3) << '\n';
    auto add_them = std::mem_fn(&Foo::add_them<short, int, float, double>);
    std::cout << "add_them(u, ...): " << add_them(u, 5, 7, 10.0f, 13.0) << '\n';
}

Ausgabe: 

Hello, world.
number: 42
data: 7
add_xy: 10
access_data(u): 7
add_xy(u, 1, 2): 10
add_many(u, ...): 13
add_them(u, ...): 42

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2048 C++11 unnötige Überladungen bereitgestellt entfernt
LWG 2489 C++11 noexcept nicht erforderlich erforderlich

Siehe auch

(C++11)
kopierbarer Wrapper für jedes kopierkonstruierbare aufrufbare Objekt
(Klassen-Template)
(C++23)
Nur-verschiebbarer Wrapper für jedes aufrufbare Objekt, das Qualifier in einer gegebenen Aufrufsignatur unterstützt
(Klassen-Template)
(C++11)
bindet ein oder mehrere Argumente an ein Funktionsobjekt
(Funktions-Template)