将rvalue引用传递给boost :: in_place函数

Question

I'm new to rvalue references in C++ and want to learn how to use them in everyday life. I've got 2 connected questions about popular usecases: using rvalue references with boost::in_place and boost::bind.

1. Using rvalue ref in boost::in_place

Consider a class, with constructor taking rvalue reference as a parameter:

struct A
    : boost::noncopyable 
{
    A(int&&){}
};

Let's now try to create boost optional variable for this class:

void foo(int&& value)
{
    boost::optional<A> opt;
    // some code here 
    opt = boost::in_place(std::forward<int>(value)); //Error!
}

What is the right way to pass rvalue ref in such an example. Is there any solution like boost::reference_wrapper for rvalue refs?

1. passing bind functor to function object with rvalue reference

Another common usecase is assigning boost::bind functor object to boost::function object.

void foo(int&&)
{
}

void bar()
{
    boost::function<void(int&&)> func;

    int x = 0;
    func = boost::bind(foo, std::move(x)); // Compilation error (a)

    func = boost::bind(foo, _1); // Compilation error too (b)
}

I understand that instruction (a) could lead to undefined variable value after first invocation, but instruction (b) even has no such a problem. But how to write this code correctly?

Answer 1

boost in_places does not natively support move or r-value references. However, you can make a new class that inherits from boost::in_place_factory_base, and make your own. Or you could use an optional that supports emplace functions (like folly::Optional).

I'm not sure I recommend doing it, but you can make a generic overload in boost to handle it, something like this:

#include <boost/optional.hpp>      
#include <boost/utility/in_place_factory.hpp>
#include <folly/ApplyTuple.h>

namespace boost                                                                      
{                                                                                  
  template<class ... As> 
  struct rvalue_in_place : public in_place_factory_base 
  {
    mutable std::tuple<As...> tup_; 
    rvalue_in_place(As ... as)
      : tup_(std::forward<As>(as)...)
   {
   }                                                                                   
   template< class T >
   void apply ( void* address ) const 
   {
     auto make = [address](As ... as) { new (address) T(std::forward<As>(as)...);  }; 
     folly::applyTuple(make, tup_); 
   }
 };   
 template <class ... As> 
 rvalue_in_place<As&&...> in_place(As && ... a)
 {
   return rvalue_in_place<As&&...>(std::forward<As>(a)...);
 }
}