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` | the return type of pm if pm is a pointer to member function, not defined for pointer to member object
`argument_type` | `T*`, possibly cv-qualified, if pm is a pointer to member function taking no arguments
`first_argument_type` | `T*` if pm is a pointer to member function taking one argument
`second_argument_type` | `T1` if pm is a pointer to member function taking one argument of type `T1`

### Member function

operator() | invokes the target on a specified object, with optional parameters (public member function)

### [edit] Exceptions

None.

### [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

Pass a member function to std::transform to create a sequence of numbers:

Run this code

    #include <iostream>
    #include <functional>
    #include <iterator>
    #include <memory>
    #include <string>
    #include <vector>
    #include <algorithm>

    int main()
    {
        std::vector<std::string> words = {"This", "is", "a", "test"};
        std::vector<std::unique_ptr<std::string>> words2;
        words2.emplace_back(new std::string("another"));
        words2.emplace_back(new std::string("test"));

        std::vector<std::size_t> lengths;
        std::transform(words.begin(),
                       words.end(),
                       std::back_inserter(lengths),
                       std::mem_fn(&std::string::size)); // uses references to strings
        std::transform(words2.begin(),
                       words2.end(),
                       std::back_inserter(lengths),
                       std::mem_fn(&std::string::size)); // uses unique_ptr to strings

        std::cout << "The string lengths are ";
        for(auto n : lengths) std::cout << n << ' ';
        std::cout << '\n';
    }

Output:

    The string lengths are 4 2 1 4 7 4

### [edit] Example 3

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=71937"