About shared_ptr and pointer to member operator `->*` and `std::bind`

Question

Recently I discovered that shared_ptr does not have pointer to member operator ->*. I created simple example:

template <typename Pointer, typename Function, typename... Args>
auto invoke1(Pointer p, Function f, Args... args) -> decltype((p->*f)(args...))
{
  return (p->*f)(args...);
}
struct A { 
    void g() { std::cout << "A::g()\n"; } 
};
int main() {
  A a;
  invoke1(&a, &A::g); // works!!
  std::shared_ptr<A> sa = std::make_shared<A>();
  invoke1(sa, &A::g); // compile error!!
}

Q1: Why is so? Why shared_ptr does not have this operator?

I added such operator for shared_ptr and the example started to work:

template <typename T, typename Result>
auto operator ->* (std::shared_ptr<T> pointer, Result (T::*function)()) ->decltype(std::bind(function, pointer))
{
    return std::bind(function, pointer);
}
template <typename T, typename Result, typename Arg1>
auto operator ->* (std::shared_ptr<T> pointer, Result (T::*function)(Arg1 arg1)) ->decltype(std::bind(function, pointer, std::placeholders::_1))
{
    return std::bind(function, pointer, std::placeholders::_1);
}

Q2: Is this right implementation for this operator? Are there somewhere any "gold" rules how to implement such operator, probably either I reinvented the wheel or go in completely wrong direction, what do you think? Is there a way to have a single function implementing this operator instead of as many function as there are placeholders in std...

After that I came to conclusion that std::bind can be used in my invoke method.

template <typename Pointer, typename Function, typename... Args>
auto invoke2(Pointer p, Function f, Args... args) 
                     -> decltype(std::bind(f, p, args...)())
{
   return std::bind(f, p, args...)();
}

In this way my example also works without need to add operator ->* to shared_ptr.

Q3: So, is std::bind now considered as a replacement for operator->*?

@Alexis - yes, I've tried and of course it works, but I considered this workaround as not important for my question. — PiotrNycz, Jul 17 '13 at 10:01
@Mehrdad There was talk to allow overloading whitespace, and I've seen overloading of the comma operator as well. Sometimes even usefully! — Alice, Feb 01 '14 at 10:50

score 6 · Accepted Answer · edited May 23 '17 at 11:43

6

In a nut shell: yes std::bind is a replacement for member function pointers.

Why? because member function pointers are awful, and their only purposes is to implement delegates, which is why std::bind and std::function do

For reference on how member function pointers are implemented, see my previous answer here. In simplest terms, member function pointers are crippled by the standard because they do not allow for calls after casts; this makes them quite pointless for the sort of behavior 90% of people want from member function pointers: delegates.

For this reason, std::function is used to represent an abstract "callable" type, with std::bind being used to bind a this to the member function pointer. You should absolutely not mess with member function pointers, and instead use std::bind and std::function.

edited May 23 '17 at 11:43

Community

1
1

answered Feb 01 '14 at 02:15

Alice

3,958
2
24
28

1

Can you somehow explain "do not allow for calls after casts", some example? I read through your linked answer - however I do miss the explanation. Anyway, +1x2 for both your answers. – PiotrNycz Feb 01 '14 at 11:53
1

@PiotrNycz One of the key features needed for using member function pointers as delegates is the ability to cast them between classes, for example, from a derived class to a base. While casting member function pointers is legal, calling one that was previously cast is not. It is undefined behavior. This means, for example, you cannot store a list of member function pointers and call them polymorphically. While this will work in almost all compilers, it is non-standard and therefore not C++. – Alice Feb 01 '14 at 11:55

score 4 · Answer 2 · answered Jan 31 '14 at 18:34

4

I believe the simplest soultion would be to replace 'structure dereference' (->) operator with a pair of derefence(*) and structure reference(.) operators:

template <typename Pointer, typename Function, typename... Args>
auto invoke1(Pointer p, Function f, Args... args) -> decltype(((*p).*f)(args...))
{
  return ((*p).*f)(args...);
}

answered Jan 31 '14 at 18:34

Lol4t0

12,444
4
29
65

This is how _INVOKE_ is defined, which mandates how `std::bind` works – K-ballo Jan 31 '14 at 18:44
1

`.*` is one operator, not two. Furthermore, `->*` is not the same as `->`. – Lightness Races in Orbit Feb 01 '14 at 21:18
you can also do this: return p.get()->f(args...); – mchiasson May 28 '14 at 14:15
@mchiasson, it will not allow pass raw pointer or some custom type of pointer that has no `get` function. But I believe every pointer supports dereference operator. – Lol4t0 May 28 '14 at 21:06

score 2 · Answer 3 · answered Jul 18 '13 at 16:16

2

I believe shared_ptr does not have operator ->* because it's impossible to implement it for arbitrary number of arguments (which C++11 allows to do for other use cases). Also, you can easily add an overload of invoke function for smart pointers that calls get(), so complicating the interface is not desirable.

answered Jul 18 '13 at 16:16

It is impossible for arbitrary number of arguments, but is possible for let say up to 30 arguments (there are 29 placeholders in my gcc compiler). So practically speaking functions with more arguments are not present in real world. The second thing is that I know there are workarounds, @Alexis already mentioned this. +1 for the observation that is cannot be done for any number of arguments. But I still want to know, maybe there are other reasons, and still want answers to other sub-questions. – PiotrNycz Jul 19 '13 at 09:27

About shared_ptr and pointer to member operator `->*` and `std::bind`

3 Answers3

Linked