Namespaces
Variants

    std::mem_fun

    Von de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Dienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreiseitiger Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Dienstprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabeltypen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Funktionsobjekte
    Funktionsaufruf
    (C++17)(C++23)
    Identitätsfunktionsobjekt
    (C++20)
    Transparente Operatorwrapper
    (C++14)
    (C++14)
    (C++14)
    (C++14)  
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    Alte Binder und Adaptoren
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)  
    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
    (bis C++17*)(bis C++17*)
    (bis C++17*)(bis C++17*)

    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
     
    Definiert in Header <functional> 
    template< class Res, class T >
std::mem_fun_t<Res,T> mem_fun( Res (T::*f)() );
    		(1) (veraltet in C++11)
    (entfernt in C++17) 
    template< class Res, class T >
std::const_mem_fun_t<Res,T> mem_fun( Res (T::*f)() const );
    		(1) (veraltet in C++11)
    (entfernt in C++17) 
    template< class Res, class T, class Arg >
std::mem_fun1_t<Res,T,Arg> mem_fun( Res (T::*f)(Arg) );
    		(2) (veraltet in C++11)
    (entfernt in C++17) 
    template< class Res, class T, class Arg >
std::const_mem_fun1_t<Res,T,Arg> mem_fun( Res (T::*f)(Arg) const );
    		(2) (veraltet in C++11)
    (entfernt in C++17)

    Erstellt ein Member-Funktions-Wrapperobjekt, wobei der Zieltyp aus den Template-Argumenten abgeleitet wird. Das Wrapperobjekt erwartet einen Zeiger auf ein Objekt vom Typ T als ersten Parameter seines operator().

    1) Ruft effektiv std::mem_fun_t<Res,T>(f) oder std::const_mem_fun_t<Res,T>(f) auf.
    2) Ruft effektiv std::mem_fun1_t<Res,T,Arg>(f) oder std::const_mem_fun1_t<Res,T,Arg>(f) auf.

    Diese Funktion und die zugehörigen Typen wurden in C++11 als veraltet erklärt und in C++17 zugunsten der allgemeineren std::mem_fn und std::bind entfernt, die beide aufrufbare adaptorkompatible Funktionsobjekte aus Member-Funktionen erstellen.

    Parameter

    f - Zeiger auf eine Member-Funktion, für die ein Wrapper erstellt werden soll

    Rückgabewert

    Ein Funktionsobjekt, das f umschließt.

    Exceptions

    Kann implementierungsdefinierte Ausnahmen auslösen.

    Hinweise

    Der Unterschied zwischen std :: mem_fun und std:: mem_fun_ref besteht darin, dass erstere einen Funktionswrapper erzeugt, der einen Zeiger auf ein Objekt erwartet, während letztere eine Referenz erwartet.

    Beispiel

    Demonstriert die Verwendung von std::mem_fun und vergleicht sie mit std::mem_fn . Ein C++11/14-kompatibler Kompilierungsmodus könnte erforderlich sein: g++/clang++ mit -std=c++11, cl mit /std:c++11, etc. Bei neueren Compilern, z.B. gcc-12, könnten "deprecated declaration"-Warnungen ausgegeben werden, wenn nicht im C++98-Modus kompiliert wird.

    Diesen Code ausführen 
    #include <functional>
#include <iostream>
struct S
{
    int get_data() const { return data; }
    void no_args() const { std::cout << "void S::no_args() const\n"; }
    void one_arg(int) { std::cout << "void S::one_arg()\n"; }
    void two_args(int, int) { std::cout << "void S::two_args(int, int)\n"; }
#if __cplusplus > 201100
    int data{42};
#else
    int data;
    S() : data(42) {}
#endif
};
int main()
{
    S s;
    std::const_mem_fun_t<int, S> p = std::mem_fun(&S::get_data);
    std::cout << "s.get_data(): " << p(&s) << '\n';
    std::const_mem_fun_t<void, S> p0 = std::mem_fun(&S::no_args);
    p0(&s);
    std::mem_fun1_t<void, S, int> p1 = std::mem_fun(&S::one_arg);
    p1(&s, 1);
#if __cplusplus > 201100
//  auto p2 = std::mem_fun(&S::two_args); // Error: mem_fun supports only member functions
                                          // without parameters or with only one parameter.
                                          // Thus, std::mem_fn is a better alternative:
    auto p2 = std::mem_fn(&S::two_args);
    p2(s, 1, 2);
//  auto pd = std::mem_fun(&S::data); // Error: pointers to data members are not supported.
                                      // Use std::mem_fn instead:
    auto pd = std::mem_fn(&S::data);
    std::cout << "s.data = " << pd(s) << '\n';
#endif
}

    Mögliche Ausgabe: 

    s.get_data(): 42
void S::no_args() const
void S::one_arg(int)
void S::two_args(int, int)
s.data = 42

    Siehe auch

    (C++11)
    		erstellt ein Funktionsobjekt aus einem Zeiger auf ein Mitglied
    (Funktions-Template)
    (deprecated in C++11) (removed in C++17)
    		erstellt einen Wrapper aus einem Zeiger auf eine Member-Funktion, aufrufbar mit einer Referenz auf ein Objekt
    (Funktions-Template)