int a = 5; 
float b = 10.0f; 
obj << Message(a,b);
 
...
 
template <typename T1, typename T1, ... , typename TN> Data<T0,T1, … , TN> Message (const T0& p0, const T1& p1, … , const TN& pN) { … }
 
...
 
auto MessageSomethingOrAnother = Message<int,float,Obj*>; 
obj << MessageSomethingOrAnother(5,6,this);
 
...
 
obj << Message(static_cast<int>(5),static_cast<float>(6),static_cast<Obj*>(this));
 

I played around with rvalue references a while ago, but only recently tried to integrate them into existing code. I have a message passing library I’ve used for some time now and thought that move semantics were perfect for it (as it basically just forwards data around). Unfortunetly I’ve come across a problem. The library dispatches based on type, so you can do something like:

int a = 5; 
float b = 10.0f; 
obj << Message(a,b);

It will send the message to the object, which will forward it to obj’s appropriate member function for processing. And the Message function is similar to what you would expect, something like:

template <typename T1, typename T1, ... , typename TN>
Data<T0,T1, … , TN> 
Message (const T0& p0, const T1& p1, … , const TN& pN) { … }

I used the boost pre-processor library to create the N instances (sorry, not trying to bore you guys, just trying to be clear). Here-in lies the problem, when I’m defining messages, I need to define the type to ensure dispatch is handled on the proper type (ie. like when passing pointers to polymorphic classes). Now that’s not always the case, but it was the case enough of the time that I defined all the messages like:

auto MessageSomethingOrAnother = Message<int,float,Obj*>; 
obj << MessageSomethingOrAnother(5,6,this);

Makes it clear and easy to catch errors. But now the magical r-value template rules don’t apply, and I can’t make use of move semantics. In fact (as far as I can tell) I’d require 2^n versions of Message just to handle the situation, which kinda defeats one of the major reasons why move semantics were put in, in the 1st place. Now of course I could use:

obj << Message(static_cast<int>(5),static_cast<float>(6),static_cast<Obj*>(this));

But that’s certainly harder to work with. Am I missing something here (and I apoligize if I am, I’m certainly no guru)? Is there a way to have perfect forwarding without requiring all the template parameters of a function to be automatically deduced? This seems like a bit of an oversight to me.

template<typename _Tp>
    inline typename std::remove_reference<_Tp>::type&&
    move(_Tp&& __t)
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

However, as far as I understand, the whole point of N2812 is that only rvalues should bind to T&&. Then only rvalues will bind to std::move(T&&) as declared above. But if std::move can only be passed rvalues, what’s the point of calling it in the first place ?!