std::bind and std::weak_ptr

Question

I have a class that creates a wrapper functor to deal with a weak_ptr to an object. When the functor executes, it will test the weak_ptr before invoking the object functor.

Additionally, the wrapper functor can return a default value if the object no longer exists.

This is an excerpt of a class that compiles under GCC 4.4.7...

class Bind
{
public:

    // non-void weak-functor
    template <typename R>
    struct Wrapper<R, typename std::enable_if<!std::is_void<R>::value>::type>
    {
        using result_type = R;

        template <typename O>
        R operator()(const std::weak_ptr<O> && obj,
                     std::function<R()> && func, R && ret)
        {
            if (auto ptr = obj.lock())
            {
                return func();
            }

            return std::forward<R>(ret);
        }
    };

    // weak from shared - non-void return
    template <typename R, typename F, typename O, typename... A>
    static std::function<R()> Weak(R && ret,
                                   F func,
                                   const std::shared_ptr<O> && obj,
                                   A&&... args)
    {
        return std::bind(Wrapper<R>(),
                         std::weak_ptr<O>(obj),
                         std::function<R()>(std::bind(func, obj.get(),
                                            std::forward<A>(args)...)),
                         ret);
    }

    // ...
};

The class can be used like this...

auto x = std::make_shared<X>();
auto f = Bind::Weak(false, &X::foo, x, 1, 2, 3);

f();   // returns x::foo(1, 2, 3) 

x.reset()

f();   // returns false

Unfortunately, after upgrading the compiler to GCC 4.8.3 it no longer compiles. The error starts like this...

error: could not convert 'std::bind(_Func&&, _BoundArgs&& ...)

...with the usual mountain of template crud. The jist is that it can no longer convert the result of std::bind() inside Bind::Weak() into the return type of Bind::Weak().

I've fiddled with this for a few hours now and haven't been able to resolve the issue.

You've [abused `std::forward`](http://stackoverflow.com/a/13219621/596781). — Kerrek SB, Oct 21 '14 at 22:52
`x` isn't an rvalue, so it seems unlikely to bind to the rvalue reference `obj` in `Bind::Weak`. — Kerrek SB, Oct 21 '14 at 22:54

score 1 · Accepted Answer · answered Oct 21 '14 at 23:01

The problem is that you cannot do perfect forwarding using a std::function because the std::function is required to be copyable, so the bound values have to be copiable, too.

Changing the operator() prototype to:

template<typename O>
R operator()(const std::weak_ptr<O>& obj, const std::function<R()>& func, const R& ret)
{
    //...
}

Should be more or less enough to make this work (it is difficult to be sure because your posted code is not complete).

But now that your forwarding into the binding is destroyed, all those std::forward and && do not make much sense, IMO.

std::bind and std::weak_ptr

1 Answers1