The compiler treats a named rvalue reference as an lvalue and an unnamed rvalue reference as an rvalue.

An rvalue reference behaves just like an lvalue reference except that it can bind to a temporary (an rvalue), whereas you can not bind a (non const) lvalue reference to an rvalue.

A &operator=(A&&)
...
a=std::forward<T>(b);

std::forward<A>(first)

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;

forwarding(std::forward<A>(first));

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;

template<typename T>
void forwarding(T &&t)
{
   A(std::forward<T>(t));
}

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;

void foo(shared_ptr<Bar>&& p) 
{ 
  /*"Рабочая лошадка"*/ 
  // . . .
}

void foo(const shared_ptr<Bar>& p) 
{ 
  foo(shared_ptr<Bar>(p)); // Создаем временную копию умного указателя 
                           // и передаем ее по rvalue-ссылке в первую функцию
}

EP>template <class T> void swap (T& a, T& b)
EP>{
EP>  T c(std::move(a)); a=std::move(b); b=std::move(c);
EP>}
EP>

#include <iostream>
#include <utility>

template <class T> 
void swap (T& a, T& b)
{
  T c(std::forward<T>(a)); a=std::forward<T>(b); b=std::forward<T>(c);
}

int main(int argc, char **argv) 
{
   int a = 1, b = 2;
   swap(a, b);
   std::cout << a << ", " << b << std::endl;
}

20.2.3 forward/move helpers

template <class T> typename remove_reference<T>::type&& move(T&& t) noexcept;

Returns: static_cast<typename remove_reference<T>::type&&>(t).

template <class T> 
void swap (T& a, T& b)
{
  T c(std::forward<T>(a)); a=std::forward<T>(b); b=std::forward<T>(c);
}

#include <iostream>
#include <ostream>
#include <utility>

template<typename T,int> void type_is();

template <int i,class T> 
void swap (T& a, T& b)
{
  type_is<decltype(std::forward<T>(a)),2*i+1>();
  type_is<decltype(std::move(a)),2*i+2>();
  T c(std::forward<T>(a)); a=std::forward<T>(b); b=std::forward<T>(c);
}

int main() 
{
   int a = 1, b = 2;
   swap<0>(a, b);
   swap<1,int&>(a, b);
   std::cout << a << ", " << b << std::endl;
}

Compilation finished with errors:
/tmp/cci7QIMZ.o: In function `main':
source.cpp: ( .text.startup+0x5 ) : undefined reference to `void type_is<int&&, 1>()'
source.cpp: ( .text.startup+0xa ) : undefined reference to `void type_is<int&&, 2>()'
source.cpp: ( .text.startup+0xf ) : undefined reference to `void type_is<int&, 3>()'
source.cpp: ( .text.startup+0x14 ) : undefined reference to `void type_is<int&&, 4>()'
collect2: error: ld returned 1 exit status

20.2.3/2

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;

2 Returns: static_cast<T&&>(t).

20.2.3/2

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;

2 Returns: static_cast<T&&>(t).

R>>Для меня это просто открытие

EP>Ну так ждём-с TC++PL 4th edition

#include <iostream>

template<typename T>
T foo(T&& t)
{
  return t;   
}

int main()
{
   int a = 0;
   foo(a) = 42;
   std::cout << a << std::endl; // Output: 42
}

template<class T>
void foo(std::unique_ptr<T> ptr);

template<class T>
void foo(std::unique_ptr<T>&& ptr); /*as "rvalue reference"*/

void f(int i)
{
...
}

void g(int& x)
{
...
}

template <class T> void swap (T& a, T& b)
{
  T c(std::move(a)); a=std::move(b); b=std::move(c);
}

f(std::move(obj));
// Что здесь можно сказать об obj ?

Unless otherwise specified, such moved-from objects shall be placed in a valid but unspecified state.

void f(Obj &&obj)
{
    // do nothing
}

C++11, by contrast, introduces the following reference collapsing rules:
A& & becomes A&
A& && becomes A&
A&& & becomes A&
A&& && becomes A&&

#include <utility>

template<typename T> void type_is();

int main()
{
   int a;
   type_is<decltype(std::forward<int>(a))>();
   type_is<decltype(std::forward<int&>(a))>();
}

Compilation finished with errors:
/tmp/cceig6tw.o: In function `main':
source.cpp: (.text.startup+0x5): undefined reference to `void type_is<int&&>()'
source.cpp: (.text.startup+0xa): undefined reference to `void type_is<int&>()'
collect2: error: ld returned 1 exit status

U>>в этом случае мне непринципиально std::forward или std::move использовать. лишь бы перемещалось

U>хватит меня запутывать!

template <class T> typename remove_reference<T>::type&& move(T&& t) noexcept;

Returns: static_cast<typename remove_reference<T>::type&&>(t).

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;

2 Returns: static_cast<T&&>(t).

#include <utility>

struct A
{
   A() { }
   A(A&&) { }
   
   A(const A&) = delete;
   A& operator=(const A&) = delete;
};

template<typename T>
void forwarding(T &&t)
{
   A(std::forward<T>(t));
}

int main()
{
   A first;
   //forwarding(std::move(first));
   forwarding(first);
}

Compilation finished with errors:
source.cpp: In instantiation of 'void forwarding(T&&) [b]with T = A&[/b]]':
source.cpp:22:20: required from here
source.cpp:15:4: error: use of deleted function 'A::A(const A&)'
source.cpp:8:4: error: declared here

bool getSomeData( ..., A& out )
{
  A ret;

  //
  // construct, update A
  // ...
  // may throw, or return false
  //

  // out is updated in atomic manner, if everything else is ok
  // c++03 analog is out.swap(ret); if there is A::swap(...)

  out = std::move(ret);
  return true;
}

1. http://liveworkspace.org/code/1ykoSY$1
   
2. http://liveworkspace.org/code/OImmo$5

forwarding(first);

template<typename T>
void forwarding(T &&t)
{
   A(std::forward<T>(t));
}

void forwarding((A&) &&t)
{
   A(std::forward<(A&)>(t));
}

void forwarding(A &t)
{
   A(std::forward<A&>(t));
}

template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;

(A&)&& forward(typename remove_reference<(A&)>::type& t) noexcept;

A& forward(A& t) noexcept;

8.3.2/6
If a typedef (7.1.3), a type template-parameter (14.3.1), or a decltype-specifier (7.1.6.2) denotes a type TR
that is a reference to a type T, an attempt to create the type “lvalue reference to cv TR” creates the type
“lvalue reference to T”, while an attempt to create the type “rvalue reference to cv TR” creates the type TR.
[ Example:

int i;
typedef int& LRI;
typedef int&& RRI;
LRI& r1 = i; // r1 has the type int&
const LRI& r2 = i; // r2 has the type int&
const LRI&& r3 = i; // r3 has the type int&
RRI& r4 = i; // r4 has the type int&
RRI&& r5 = 5; // r5 has the type int&&
decltype(r2)& r6 = i; // r6 has the type int&
decltype(r2)&& r7 = i; // r7 has the type int&

—end example ]

auto &&v = ...;
or
template<typename T>
void f(T &&v);

R>Для меня это просто открытие