Can a std::function store pointers to data members?

Question

From cppreference, I found that:

Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target -- functions, lambda expressions, bind expressions, or other function objects, as well as pointers to member functions and pointers to data members.

I cannot see why a std::function should be able to store such a pointer and I've never heard before about that feature.
Is it really possible, I missed something or that's an error in the documentation?

How should the operator() behave in such a case?
As from the documentation:

Invokes the stored callable function target with the parameters args.

Anyway, there is no stored callable function target to invoke here. Am I wrong?

To be honest, I cannot even figure out what's the right syntax for such a function, otherwise I'd have written an example to test it.
How could the following template be used to define a pointer to data member?

template< class R, class... Args >
class function<R(Args...)>

Ok, so the idea is the same used for member methods: the signature is exactly the same, but for the first parameter that is the instance on which to invoke them. A similar approach can be used for data members, is it? Interesting. — skypjack, Feb 16 '16 at 17:51
@Otomo see the example in the first comment, that's not because of what you say, I'm sorry — skypjack, Feb 16 '16 at 18:05
@skypjack [another example?](http://coliru.stacked-crooked.com/a/0f7c6f9953b04998) — Piotr Skotnicki, Feb 22 '16 at 18:59
@PiotrSkotnicki A good one for sure, even more with a few details of context. That's a bounty for the sake of curiosity, so I'll assign it the last day, each example is welcome till that day. Thank you. :-) — skypjack, Feb 22 '16 at 20:08

score 25 · Accepted Answer · edited Nov 15 '19 at 17:41

25

The effect of a call to the function call operator of std::function<R(ArgTypes...)>:

R operator()(ArgTypes... args) const

is equivalent to (§ 20.9.11.2.4 [func.wrap.func.inv]/p1):

INVOKE<R>(f, std::forward<ArgTypes>(args)...)

whose definition includes the following bullet (§ 20.9.2 [func.require]/p1):

Define INVOKE(f, t1, t2, ..., tN) as follows:

[...]

^1.3 — t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is an object of type T or a reference to an object of type T or a reference to an object of a type derived from T;

then, when f is a pointer to a data member stored in an internal invoker of a std::function, then the std::function itself should define a single argument, e.g.:

std::function<int(std::pair<int,int>)> f = &std::pair<int,int>::first;

f(std::make_pair(1, 2));

DEMO

edited Nov 15 '19 at 17:41

HTNW

22,326
1
24
53

answered Feb 16 '16 at 18:07

Piotr Skotnicki

43,267
7
101
142

Being the return type of the *function* the actual type of the data member, right? – skypjack Feb 16 '16 at 18:28
1

That `R` at the end of *INVOKE* means "*implicitly convertible to R*", so the type of the stored data member can be convertible to what `std::function` defines – Piotr Skotnicki Feb 16 '16 at 18:31
Wow, even more powerful than what I guessed. Still I can't see any real use of such a feature, but this cannot lessen its beauty!! Really thank you for your responses, as usual, very appreciated. :-) – skypjack Feb 16 '16 at 18:36
3

@skypjack They are very useful as projections. – T.C. Feb 17 '16 at 02:47
1

@T.C. It sounds interesting and you know that I want to understand!! :-) ... Would it be possible that you add one more answer with such an example of use? It will have my upvote for sure. – skypjack Feb 17 '16 at 06:51

Can a std::function store pointers to data members?

1 Answers1