std::mem_fn

Défini dans l'en-tête `<functional>`
template< class M, class T > /* unspecified / mem_fn( M T:: pm ) noexcept;		(depuis C++11) (constexpr depuis C++20)

Le modèle de fonction std::mem_fn génère des objets encapsulant des pointeurs vers des membres, qui peuvent stocker, copier et invoquer un pointeur vers un membre. Les références et les pointeurs (y compris les pointeurs intelligents) vers un objet peuvent être utilisés lors de l'invocation d'un std::mem_fn.

Paramètres

pm

-

pointeur vers membre qui sera encapsulé

Valeur de retour

std::mem_fn renvoie un wrapper d'appel fn de type non spécifié qui possède les membres suivants :

std::mem_fn type de retour

Types membres

type	définition
`result_type` (obsolète en C++17)	le type de retour de pm si pm est un pointeur vers une fonction membre, non défini pour un pointeur vers un objet membre
`argument_type` (obsolète en C++17)	`T*` , éventuellement qualifié cv, si pm est un pointeur vers une fonction membre ne prenant aucun argument
`first_argument_type` (obsolète en C++17)	`T*` si pm est un pointeur vers une fonction membre prenant un argument
`second_argument_type` (obsolète en C++17)	`T1` si pm est un pointeur vers une fonction membre prenant un argument de type `T1`

(jusqu'à C++20)

Fonction membre

template < class ... Args > /* voir ci-dessous / operator ( ) ( Args && ... args ) / qualificateurs cvref / noexcept ( / voir ci-dessous */ ) ;		(constexpr depuis C++20)

L'expression fn ( args ) est équivalente à INVOKE ( pmd, args ) , où pmd est l'objet Callable détenu par fn , il est de type M T::* et est initialisé par initialisation directe non-liste avec pm .

Ainsi, le type de retour de operator ( ) est std:: result_of < decltype ( pm ) ( Args && ... ) > :: type ou de manière équivalente std:: invoke_result_t < decltype ( pm ) , Args && ... > , et la valeur dans le spécificateur noexcept est égale à std:: is_nothrow_invocable_v < decltype ( pm ) , Args && ... > ) (depuis C++17) .

Chaque argument dans args est parfaitement transféré, comme par std:: forward < Args > ( args ) ... .

Exemple

Utilisez std::mem_fn pour stocker et exécuter une fonction membre et un objet membre :

Exécuter ce code

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

Sortie :

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Applicable à	Comportement publié	Comportement corrigé
LWG 2048	C++11	surcharges inutiles fournies	supprimées
LWG 2489	C++11	noexcept non requis	requis

Voir aussi

function (C++11)	enveloppe copiable de tout objet appelable copiable (modèle de classe)
move_only_function (C++23)	enveloppe non copiable de tout objet appelable prenant en charge les qualificateurs dans une signature d'appel donnée (modèle de classe)
bind (C++11)	lie un ou plusieurs arguments à un objet fonction (modèle de fonction)

Support du compilateur
Libre et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et d'heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants