Why doesn't auto_ptr support op->*()

Question

auto_ptr (shared_ptr as well) try to make their use as transparent as possible; that is, ideally, you should not be able to tell a difference whether you're using an auto_ptr or a real pointer to an object. Consider:

class MyClass
{
public:
    void foo() {  }
};

MyClass* p = new MyClass;
auto_ptr<MyClass> ap(new MyClassp);

p->foo();       // No notational difference in using real
ap->foo();      // pointers and auto_ptrs

When you try to invoke a member function through a pointer-to-member, there is a difference, as auto_ptr obviously doesn't implement op->*():

void (MyClass::*memfun)() = &MyClass::foo;

(p->*memfun)();         // OK
(ap->*memfun)();        // Error op->*() missing
(ap.get()->*memfun)();  // OK

Why is there no support for op->*() in auto_ptr and how would one implement it (I've experimented for some time, but ultimately gave up).

Answer 1

As Luther points out its non-trivial to implement - but it is possible.

You have to

1. use templates so the type of the arguments to operator->* can be deduced
2. take care of possible qualifiers and multiple function arities using overloads
3. for member function pointers return a callabe object that is:
   • bound to the instance the smart pointer points to
   • implements an operator() with a signature equivalent to the member function

Ignoring qualifiers for the momement, here is how it could basically look (using C++0x to avoid manual repitition):

// pointer to data member:

template<class T, class D>
D& operator->*(std::auto_ptr<T>& p, D T::*mp) {
    return (*p).*mp;
}

// pointer to member function:

template<class T, class R, class... Args> struct Callable {
    typedef R (T::*MFP)(Args...);
    MFP mfp;
    T& instance;

    Callable(T t, MFP mfp) : instance(t), mfp(mfp) {}

    R operator()(Args... a) {
        return (instance.*mfp)(a...);
    }
};

template<class T, class R, class... Args>
Callable<T, R, Args...>
operator->*(std::auto_ptr<T>& p, R (T::*mfp)(Args...)) {
    return Callable<T, R, Args...>(*p, mfp);
}

But in the end, why bother when we could just use functors that bind member pointers in the first place.

While i can't be sure about it, if you combine the knowledge that

• the implementation is non-trivial
• there is an easy alternative that works just as well ((*p).*m)

... its probably usually not implemented due to a bad ratio of the work-needed to the gains resulting from this feature.

Answer 2

implementing ->* would require to solve the perfect forwarding problem:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm

operator->* would have to return a callable object with the same parameter list as the pointer-to-member object, correctly handling const-,volatileness and reference types. And then it would have to employ special magic powers to handle default parameters. This is difficult, error prone, unsolvable and eats too much compile time and since pointer-to-members are a comparably marginally popular feature of C++, they are generally left out of smart pointer implementations.

Answer 3

I may be wrong, but I think there's no way to overload operator->* for a pointer-to-member-function. This is because p->*memfun, while valid as part of an expression that treats it as a callable object, isn't a valid expression in its own right, and doesn't have a type. There is therefore no valid type for the operator to return.

The following will work for a pointer-to-member, but trying to use it for a pointer-to-member-function gives an error, "invalid use of non-static member function", with GCC, and an internal compiler error with MSVC.

template <class CLASS, typename MEMBER>
MEMBER& operator->*(std::auto_ptr<CLASS>& p, MEMBER CLASS::*m)
{
    return (*p).*m;
}

EDIT: as Georg's answer points out, you can use boost::bind or similar to create a set of overloads for member functions up to a fixed maximum number of arguments, but there's still no way to overload the operator for all possible member functions.