std::mem_fn

Определён в заголовочном файле `<functional>`
template< class M, class T > /* unspecified / mem_fn( M T:: pm ) noexcept;		(начиная с C++11) (constexpr начиная с C++20)

Шаблон функции std::mem_fn создаёт объекты-обёртки для указателей на члены, которые могут хранить, копировать и вызывать указатель на член. При вызове std::mem_fn можно использовать как ссылки, так и указатели (в том числе интеллектуальные указатели) на объект.

Параметры

указатель на член, который будет обёрнут

Возвращаемое значение

std::mem_fn возвращает оболочку вызова fn неуказанного типа, которая имеет следующие члены:

Тип возвращаемого значения std::mem_fn

Типы-члены

тип	определение
`result_type`(устарело в C++17)	тип возвращаемого значения `pm`, если `pm` является указателем на функцию-член; не определён для указателя на объект-член
`argument_type`(устарело в C++17)	`T*`, возможно, с квалификаторами cv, если `pm` является указателем на функцию-член, не принимающую аргументов
`first_argument_type`(устарело в C++17)	`T*`, если `pm` является указателем на функцию-член, принимающую один аргумент
`second_argument_type`(устарело в C++17)	`T1`, если `pm` является указателем на функцию-член, принимающую один аргумент типа `T1`

(до C++20)

Функция-член

template< class... Args >
/* see below */ operator()(Args&&... args) /* cvref-qualifiers */
    noexcept(/* see below */);

(constexpr начиная с C++20)

Выражение fn(args) эквивалентно INVOKE(pmd,args), где pmd — объект Callable, хранящийся в fn; он имеет тип M T::* и инициализируется напрямую, без списка инициализаторов, с помощью pm.

Таким образом, типом возвращаемого значения operator() является std::result_of<decltype(pm)(Args&&...)>::type или, что эквивалентно, std::invoke_result_t<decltype(pm),Args&&...>, а значение в спецификаторе noexcept равно std::is_nothrow_invocable_v<decltype(pm), Args&&...>)(начиная с C++17).

Каждый аргумент в args передаётся с идеальной пересылкой, как если бы использовалось std::forward<Args>(args)....

Пример

Используйте std::mem_fn для хранения и вызова функции-члена и объекта-члена:

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

Вывод:

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

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

DR	Применяется к	Опубликованное поведение	Корректное поведение
LWG 2048	C++11	предоставлялись ненужные перегрузки	удалены
LWG 2489	C++11	noexcept не требовался	требуется

См. также

function (C++11)	копируемая оболочка для любого копируемого объекта Callable (шаблон класса)
move_only_function (C++23)	оболочка только с перемещением для любого объекта Callable, поддерживающего квалификаторы в заданной сигнатуре вызова (шаблон класса)
bind (C++11)	связывает один или несколько аргументов с функциональным объектом (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/functional/mem_fn