std::mem_fn - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::mem_fn

From cppreference.com
< cpp‎ | utility‎ | functional

Defined in header `<functional>` |  |
template< class R, class T > /*unspecified*/ mem_fn(R T::* pm); | (1) | (since C++11)
template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...)); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &&); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &&); | (2) | (since C++11) (until C++14)

Function template `std::mem_fn` generates wrapper objects for pointers to members, which can store, copy, and invoke a pointer to member. Both references and pointers (including smart pointers) to an object can be used when invoking a `std::mem_fn`.

The overloads (2) were introduced in C++11 but removed in C++14 as defect #2048

### [edit] Parameters

pm | - | pointer to member that will be wrapped

### [edit] Return value

`std::mem_fn` returns a call wrapper of unspecified type that has the following members:

## std::mem_fn Return type

### Member types

type | definition
`result_type`(deprecated in C++17) | the return type of pm if pm is a pointer to member function, not defined for pointer to member object
`argument_type`(deprecated in C++17) | `T*`, possibly cv-qualified, if pm is a pointer to member function taking no arguments
`first_argument_type`(deprecated in C++17) | `T*` if pm is a pointer to member function taking one argument
`second_argument_type`(deprecated in C++17) | `T1` if pm is a pointer to member function taking one argument of type `T1`

### Member function

template<class... Args> /* see below */ operator()(Args&&... args); |  |

Let `fn` be the call wrapper returned by a call to `std::mem_fn` with a pointer to member `pm`. Then the expression fn(t, a2, ..., aN) is equivalent to INVOKE(pm, t, a2, ..., aN), where INVOKE is the operation defined in `Callable`. (Thus, the return type of `operator()` is std::result_of<decltype(pm)(Args&&...)>::type.)

Each argument in `args` is perfectly forwarded, as if by std::forward<Args>(args)....

### [edit] Exceptions

(none) | (until C++17)
`noexcept` specification: noexcept | (since C++17)

### [edit] Example 1

Use `mem_fn` to store and execute a member function and a member object:

Run this code

    #include <functional>
    #include <iostream>

    struct Foo {
        void display_greeting() {
            std::cout << "Hello, world.\n";
        }
        void display_number(int i) {
            std::cout << "number: " << i << '\n';
        }
        int data = 7;
    };

    int main() {
        Foo f;

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

Output:

    Hello, world.
    number: 42
    data: 7

### [edit] Example 2

Demonstrates the effect of the C++14 changes to the specification of std::mem_fn

Run this code

    #include <iostream>
    #include <functional>

    struct X {
        int x;

        int&       easy()      {return x;}
        int&       get()       {return x;}
        const int& get() const {return x;}
    };

    int main(void)
    {
        auto a = std::mem_fn        (&X::easy); // no problem at all
    //  auto b = std::mem_fn<int&  >(&X::get ); // no longer works in C++14
        auto c = std::mem_fn<int&()>(&X::get ); // works with both C++11 and C++14
        auto d = [] (X& x) {return x.get();};   // another approach to overload resolution

        X x = {33};
        std::cout << "a() = " << a(x) << '\n';
        std::cout << "c() = " << c(x) << '\n';
        std::cout << "d() = " << d(x) << '\n';
    }

Output:

    a() = 33
    c() = 33
    d() = 33

### [edit] See also

function (C++11) | wraps callable object of any type with specified function call signature (class template) [edit]
bind (C++11) | binds one or more arguments to a function object (function template) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/mem_fn&oldid=91680"
Category:

- unconditionally noexcept

Hidden categories:

- Pages with unreviewed unconditional noexcept template
- Pages with unreviewed noexcept template