(rvalue reference) VS (const lvalue reference) as function parameters in C++11

Question

Can someone explain when rvalue references are preferred over const lvalue references when working as function parameters?

Background: I was trying to pass a const pointer into a function. Since I have to consider the cases in which a local pointer is passed in and in which a temporary is passed in (say from a function call return), I have two choices: the parameter could either be declared as:

void foo(T const* const&); //const lvalue ref to const ptr

or

void foo(T const* &&); //rvalue ref to const ptr

But this rvalue reference cannot be bound to a local variable (which is of lvalue type. But I did remember Scott Meyers coined the term "universal reference" to refer to rvalue reference. This confuses me more.) So my question is, since the first declaration could deal with both cases, when would the second one using rvalue reference be preferred?

Note: In the first approach, the other forms

void foo(const const T* &); 
void foo(const T* const&); 

didn't work. I guess the reason is that in the latter two I was not consistent in the place where the const qualifiers are put into (please correct me if I'm wrong).

Answer 1

It is very rarely a good idea to pass a pointer by const &: at best it takes the same overhead, at worst it causes extremely complex pointer reseating logic to surprise readers of your code.

Take pointers by value -- T const* -- and things are more sane.

References to non-pointer values make more sense.

Universal references is a technique using rvalue and lvalue references in a type deduction context. It basically only applies when you have a type T&& being deduced from an expression -- in that context T can be X, X& or X const& (or other cv variants).

If T is X& or X const&, the rvalue reference to the lvalue reference collapses into a lvalue reference. It is an example of the standard committee being clever, and it allows auto&&x= based universal reference variables, and perfect forwarding code to be easy to write.