Why std::bind() doesn't work with constants in this scenario?

Question

Let me start with explaining what I try to accomplish. I need to create a type-erased functor (using templates and virtual functions) that would be able to "emplace" a new object in the storage of message queue for the RTOS I'm developing. Such "trickery" is required, because I want most of message queue's code to be non-templated, with only the parts that really need the type info implemented as such type-erased functors. This is a project for embedded microcontrollers (*), so please assume that I just cannot make whole message queue with a template, because ROM space is not unlimited in such environment.

I already have functors that can "copy-construct" and "move-construct" the object into the queue's storage (for "push" operations) and I also have a functor that can "swap" the object out of the queue's storage (for "pop" operations). To have a complete set I need a functor that will be able to "emplace" the object into the queue's storage.

So here is the minimum example that exhibits the problem I'm facing with creating it. Do note that this is a simplified scenario, which doesn't show much of the boiler plate (there are no classes, no inheritance and so on), but the error is exactly the same, as the root cause is probably the same too. Also please note, that the use of std::bind() (or a similar mechanism that would NOT use dynamic allocation) is essential to my use case.

#include <functional>

template<typename T, typename... Args>
void emplacer(Args&&... args)
{
    T value {std::forward<Args>(args)...};
}

template<typename T, typename... Args>
void emplace(Args&&... args)
{
    auto boundFunction = std::bind(emplacer<T, Args...>,
            std::forward<Args>(args)...);
    boundFunction();
}

int main()
{
    int i = 42;
    emplace<int>(i);        // <---- works fine

    emplace<int>(42);       // <---- doesn't work...
}

When compiled on PC with g++ -std=c++11 test.cpp the first instantiation (the one using a variable) compiles with no problems, but the second one (which uses a constant 42 directly) throws this error messages:

test.cpp: In instantiation of ‘void emplace(Args&& ...) [with T = int; Args = {int}]’:
test.cpp:21:17:   required from here
test.cpp:13:16: error: no match for call to ‘(std::_Bind<void (*(int))(int&&)>) ()’
  boundFunction();
                ^
In file included from test.cpp:1:0:
/usr/include/c++/4.9.2/functional:1248:11: note: candidates are:
     class _Bind<_Functor(_Bound_args...)>
           ^
/usr/include/c++/4.9.2/functional:1319:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) [with _Args = {_Args ...}; _Result = _Result; _Functor = void (*)(int&&); _Bound_args = {int}]
  operator()(_Args&&... __args)
  ^
/usr/include/c++/4.9.2/functional:1319:2: note:   template argument deduction/substitution failed:
/usr/include/c++/4.9.2/functional:1315:37: error: cannot bind ‘int’ lvalue to ‘int&&’
  = decltype( std::declval<_Functor>()(
                                     ^
/usr/include/c++/4.9.2/functional:1333:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) const [with _Args = {_Args ...}; _Result = _Result; _Functor = void (*)(int&&); _Bound_args = {int}]
  operator()(_Args&&... __args) const
  ^
/usr/include/c++/4.9.2/functional:1333:2: note:   template argument deduction/substitution failed:
/usr/include/c++/4.9.2/functional:1329:53: error: invalid initialization of reference of type ‘int&&’ from expression of type ‘const int’
          typename add_const<_Functor>::type>::type>()(
                                                     ^
/usr/include/c++/4.9.2/functional:1347:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) volatile [with _Args = {_Args ...}; _Result = _Result; _Functor = void (*)(int&&); _Bound_args = {int}]
  operator()(_Args&&... __args) volatile
  ^
/usr/include/c++/4.9.2/functional:1347:2: note:   template argument deduction/substitution failed:
/usr/include/c++/4.9.2/functional:1343:70: error: invalid initialization of reference of type ‘int&&’ from expression of type ‘volatile int’
                        typename add_volatile<_Functor>::type>::type>()(
                                                                      ^
/usr/include/c++/4.9.2/functional:1361:2: note: template<class ... _Args, class _Result> _Result std::_Bind<_Functor(_Bound_args ...)>::operator()(_Args&& ...) const volatile [with _Args = {_Args ...}; _Result = _Result; _Functor = void (*)(int&&); _Bound_args = {int}]
  operator()(_Args&&... __args) const volatile
  ^
/usr/include/c++/4.9.2/functional:1361:2: note:   template argument deduction/substitution failed:
/usr/include/c++/4.9.2/functional:1357:64: error: invalid initialization of reference of type ‘int&&’ from expression of type ‘const volatile int’
                        typename add_cv<_Functor>::type>::type>()(

I tried looking for inspiration in other places, but Intel's TBB library which has a similar code (concurent_queue) with similar functionality (there's an emplace function) is actually no emplace at all - it constructs the object instantly and just "moves" it into the queue...

Any idea what's wrong with the code above? I suppose it's something really small, but I just cannot solve that myself...

---

(*) - https://github.com/DISTORTEC/distortos

Answer 1

You've already had an explanation of how that is just how std::bind works (it turns everything into an lvalue), and to use a lambda instead. However, that is not exactly trivial. Lambdas can capture by value, or by reference. You sort of need a mix of both: rvalue references should be assumed to possibly reference temporaries, so should be captured by value, with move semantics. (Note: that does mean that the original object gets moved from before the lambda gets invoked.) Lvalue references should be captured by reference, for probably obvious reasons.

One way to make this work is to manually put the captured arguments in a tuple of lvalue reference types and non-reference types, and unpack when you want to invoke the function:

template <typename T>
struct remove_rvalue_reference {
  typedef T type;
};

template <typename T>
struct remove_rvalue_reference<T &&> {
  typedef T type;
};

template <typename T>
using remove_rvalue_reference_t = typename remove_rvalue_reference<T>::type;

template <typename F, typename...T, std::size_t...I>
decltype(auto) invoke_helper(F&&f, std::tuple<T...>&&t,
                             std::index_sequence<I...>) {
  return std::forward<F>(f)(std::get<I>(std::move(t))...);
}

template <typename F, typename...T>
decltype(auto) invoke(F&&f, std::tuple<T...>&&t) {
  return invoke_helper<F, T...>(std::forward<F>(f), std::move(t),
                                std::make_index_sequence<sizeof...(T)>());
}

template<typename T, typename... Args>
void emplacer(Args&&... args) {
  T{std::forward<Args>(args)...};
}

template<typename T, typename...Args>
void emplace(Args&&...args)
{
    auto boundFunction =
      [args=std::tuple<remove_rvalue_reference_t<Args>...>{
          std::forward<Args>(args)...}]() mutable {
        invoke(emplacer<T, Args...>, std::move(args));
      };
    boundFunction();
}

When calling emplace with args T1 &, T2 &&, the args will be captured in a tuple<T1 &, T2>. The tuple gets unpacked (thanks to @Johannes Schaub - litb for the basic idea) when finally invoking the function.

The lambda needs to be mutable, to allow that captured tuple to be moved from when invoking the function.

This uses several C++14 features. Most of these can be avoided, but I don't see how to do this without the ability to specify an initialiser in the capture list: C++11 lambdas can only capture by reference (which would be reference to the local variable), or by value (which would make a copy). In C++11, I think that means the only way to do it is not use a lambda, but effectively re-create most of std::bind.

Answer 2

To expand on @T.C.'s comment, you can make the code work by changing the type of the created emplacer.

auto boundFunction = std::bind(emplacer<T, Args&...>,
        std::forward<Args>(args)...);

Notice the & right after Args. The reason is you're passing an rvalue to the emplace function which in turn creates emplacer(int&&). std::bind however always passes an lvalue (because it comes from its internals). With the change in place, the signature changes to emplacer(int&) (after reference collapsing) which can bind to an lvalue.