C++ 右值语义相关总结

int a = 0;  // a是左值，0是右值
int b = rand(); // b是左值，rand()是右值

A& + A& = A&
A& + A&& = A&
A&& + A& = A&
A&& + A&& = A&&

X::X() 
{
 // 申请资源(指针表示)
}

X::X(const X& other)
{
 // ...
 // 销毁资源 
 // 克隆other中的资源
 // ...
}

X::~X() 
{
 // 销毁资源
}

X tmp;
// ...经过一系列初始化...
X a = tmp;

X::X(const X& other)
{
 // 使用std::swap交换this和other的资源  
}

template<class T> 
typename remove_reference<T>::type&&
std::move(T&& a) noexcept
{
 typedef typename remove_reference<T>::type&& RvalRef;
 return static_cast<RvalRef>(a);
}

#include <utility>    
#include <iostream>   
#include <string>    
#include <vector>    
        
void foo(const std::string& n) 
{        
 std::cout << "lvalue" << std::endl;
}        
        
void foo(std::string&& n)  
{        
 std::cout << "rvalue" << std::endl;
}        
        
void bar()      
{        
 foo("hello");    // rvalue
 std::string a = "world";  
 foo(a);      // lvalue
 foo(std::move(a));   // rvalue
}

int main()
{
 std::vector<std::string> a = {"hello", "world"};
 std::vector<std::string> b;

 b.push_back("hello");   // 开销：string复制构造
 b.push_back(std::move(a[1])); // 开销：string移动构造(将临时变量a[1]中的指针偷过来)

 std::cout << "bsize: " << b.size() << std::endl;
 for (std::string& x: b)
 std::cout << x << std::endl;
 bar();
 return 0;
}

#include <utility>
#include <iostream>

void bar(const int& x)
{
 std::cout << "lvalue" << std::endl;
}

void bar(int&& x)
{
 std::cout << "rvalue" << std::endl;
}

template <typename T>
void foo(T&& x)
{
 bar(x);
}

int main()
{
 int x = 10; 
 foo(x); // 输出：lvalue
 foo(10); // 输出：lvalue
 return 0;
}

template <typename T>
void foo(T&& x)
{
 bar(std::forward<T>(x));
}

template<typename T, typename Arg> 
shared_ptr<T> factory(Arg&& arg)
{ 
 return shared_ptr<T>(new T(std::forward<Arg>(arg)));
}
template<class S>
S&& forward(typename remove_reference<S>::type& a) noexcept
{
 return static_cast<S&&>(a);
}

X x;
factory<A>(x);

#include <utility>
#include <iostream>

void overloaded(const int& x)
{
 std::cout << "[lvalue]" << std::endl;
}

void overloaded(int&& x)
{
 std::cout << "[rvalue]" << std::endl;
}

template <class T> void fn(T&& x)
{
 overloaded(x);
 overloaded(std::forward<T>(x));
}

int main()
{
 int i = 10; 
 overloaded(std::forward<int>(i));
 overloaded(std::forward<int&>(i));
 overloaded(std::forward<int&&>(i));
 
 fn(i);
 fn(std::move(i));

 return 0;
}