Зачем нужны rvalue ссылки, если есть универсальные ссылки

class A
{
public:
    A() { std :: cout << "Constructor A" << std :: endl; p = 5; }
    ~A() { std :: cout << "Destructor A" << std :: endl; }
    
    int p;
};
 
void foo( A&& rvalue )
{
    rvalue.p = 7;
}
 
template<class T>
void foo2( T&& universalRef )
{
    universalRef.p = 7;
}
 
int main()
{
    A object;
    foo2( A() );    // нет ошибок rvalue
    foo2(object );    // нет ошибок lvalue
 
    foo( A() ); // нет ошибок rvalue
    foo(object ); // ошибка, нужно привести object к rvalue, тоесть std::move(object)
    
}

void foo(A&& rvalue) //сюда можно передать только rvalue 
template<class T>
void foo2(T&& arg1, T&& arg2, T&& arg3) // передавайте сюда что хотите - если это будет rvalue, то я буду работать эффективнее, если lvalue - то как обычно

void foo2(T&& arg1, T&& arg2, T&& arg3) // передавайте сюда что хотите - если это будет rvalue, то я буду работать эффективнее

#include <iostream>
#include <memory>
#include <vector>
 
 
int main()
{
    std::unique_ptr<int> p = std::make_unique<int>(42);
    std::vector<std::unique_ptr<int>> v;
    // v.push_back(p); error
    v.push_back(std::move(p)); // OK
}

#include <iostream>
#include <memory>
#include <vector>
 
 void foo( const std::unique_ptr<int>& value )
 {
 }
 
int main()
{
    std::unique_ptr<int> p = std::make_unique<int>(42);
    std::vector<std::unique_ptr<int>> v;
    // v.push_back(p); error
    v.push_back(std::move(p)); // OK
    foo( p );
    foo(std :: move(p) );
}

#include <iostream>
 
template <typename T>
void foo(const T &)
{
    std::cout << "(const T &)\n";
}
 
template <typename T, typename std::enable_if<!std::is_copy_constructible<T>::value>::type * = 0>
void foo(T &&)
{
    std::cout << "(T &&)\n";
}
 
struct Bar
{
    Bar() = default;
    Bar(const Bar &) = delete;
};
 
int main()
{
    foo(int());
    foo(Bar());
}

#include <iostream>
 
 void foo( const int& value )
 {
 }
 
 template<class T>
 void foo2( T&& value )
 {
 }
 
int main()
{
    int p = 5;
    
    foo( p ); // lvalue (1)
    foo( std :: move( p ) ); // rvalue (2)
    foo2( p ); //lvalue (3)
    foo2( std :: move( p ) ); // rvalue (4)
}

 template<class T>
 void foo2( T&& value )
 {
 }

 template<class ... Args>
 void foo2( Args &&... value )
 {
 }

/////////////////////////////////////////////////////////////////////////////////////////
template<typename Tp>
void foo(Tp&&)
{}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    int n;
    foo(n); // в foo Tp == int& &&(о боже, ссылка на ссылку!!! убрать срочно!!!) -> Tp == int& -> lvalue
    foo(int{}); // в foo Tp == int&& -> rvalue
}