C++11特性之左值引用和右值引用

3.1二者的对比之内置类型

内置类型的无名对象（右值）为纯右值，其值本身不可改变

int main()
{
    int a=10;
    const int b=20;
    int& ra=a;//ok,左值引用
    const int& rb=b;//ok，常性左值引用
    
    const int& crv=30;//ok,也叫万能引用，即可以引用左值也可以引用右值
    /*上句实际上是变为：
    int tmp=30;
    const int& crv=tmp;*/
    int&& rv=30;//ok,右值引用
     /*上句实际上是变为：
    int tmp=30;
    int& rv=tmp;*/
    //常性左值引用和右值引用的区别：
    crv+=100;//error
    rv+=100;//ok,不是将30改为100，30为纯右值，不能改变。实际是将tmp的值改为100
    return 0;
}

3.2二者的对比之自己设计的类型

自己设计的类型的无名对象（右值）为将亡值，其值可以改变

class Int
{
	int value;
public:
	Int(int x = 0) :value(x) { cout << "create " << this << endl; }
	~Int() { cout << "destroy " << this << endl; }
	Int(const Int& it) :value(it.value)
	{
		cout << &it << " copy " << this << endl;
	}
	Int& operator=(const Int& it)
	{
		if (this != &it)
		{
			value = it.value;
		}
		cout << &it << " operator= " << this << endl;
		return *this;
	}
    void PrintValue()const
    {
        cout<<"value: "<<value<<endl;
    }
    Int& SetValue(int x)
    {
        value=x;
        return *this;
    }
};
Int fun(int x)
{
	Int tmp(x);
	return tmp;
}
int main()
{
    /*
    Int a(10);//左值
    const Int b(20);//常左值
    Int& ra=a;//左值引用
    const Int& rb=b;//常性左值引用
    */
    Int&& rv=Int(30);//右值引用，引用无名对象
    Int&& rf=fun(40);//引用函数返回值的将亡值对象
    rv.PrintValue();//ok
    rv.SetValue(300);//ok
    rv.PrintValue();
    rf.PrintValue();//ok
    rf.SetValue(400);//ok
    rf.PrintValue();
    return 0;
}

结果：

 

3.3将亡值的生存期问题

3.3.1使用无名对象作为例子：

int main()
{
    Int(10).PrintValue();
    cout<<"main end"<<endl;
    return 0;
}

结果：

 

将亡值在该行语句执行完后就会消亡，而不是等到主函数结束才消亡，其生存期就只在其调用点处。

当使用右值引用引用该无名对象（将亡值）时：

int main()
{
    Int&& rv=Int(30);
    rv.PrintValue();
    cout<<"main end"<<endl;
    return 0;
}

结果：

由此来看，使用右值引用去引用将亡值，该将亡值的生存期就会和右值引用的标识符相同。

3.3.2以函数返回值作为例子：

int main()
{
    fun(10).PrintValue();
    cout<<"main end"<<endl;
    return 0;
}

结果：

当使用右值引用引用该无名对象（将亡值）时：

 

int main()
{
    Int&& rf=fun(10);
    rf.PrintValue();
    rf.SetValue(100);
    rf.PrintValue();
    cout<<"main end"<<endl;
    return 0;
}

 结果：

与使用无名对象作为例子时的结果相同。

总结：将亡值在该行语句执行完后就会消亡，而不是等到主函数结束才消亡，其生存期就只在其调用点处。但是使用右值引用去引用将亡值，该将亡值的生存期就会和右值引用的标识符相同。

3.3.3将右值引用设置为静态，其生存期如何

int func()
{
	static Int&& rf=fun(10);//.data区
    rf.PrintValue();
    rf.SetValue(100);
    rf.PrintValue();
    cout<<"func end"<<endl;
    return 0;
}
int main()
{
    cout<<"main begin"<<endl;
    func();
    cout<<"main end"<<endl;
    return 0;
}

结果：

 

右值引用引用将亡值后，将亡值的生存期就随从右值引用的标识符的生存期，而右值引用rf为静态右值引用，存储在.data区，.data区的数据是在程序运行结束才进行释放，所以当整个程序结束才会销毁该将亡值。

如果rf为非静态右值引用时，将亡值的生存期就只在func函数中有效，即结果为：

3.4具名右值->泛左值

 

int main()
{
    Int&& rv=Int(30);
    Int&& rf=fun(40);
    int&& a=10;
    a+=1;//ok
    &rv;//ok
    &rf;//ok
    &a;//ok
    Int&& ra=rv;//error
    Int&& rb=rf;//error
    int&& b=a;//error
    //此时，rv、rf和a都可以取地址，被称为泛左值，所以不可以再用右值引用去引用rv/rf和a
    Int& rc=rv;//ok
    Int& rd=rf;//ok
    int& c=a;//ok
    const Int& re=rv;//ok
    const Int& rg=rf;//ok
    const int& d=a;
    return 0;
}

3.5值类别转换

int main()
{
    Int a(10);//左值
    const Int b(20);//常左值
    Int&& rv=Int(30);//右值
    //如何让右值引用引用左值:
    Int&& ra=a;//error
    Int&& rb=static_cast<Int&&>(a);//ok,C++的静态类型转换
    Int&& rc=const_cast<Int&&>(b);//ok,C++的去常性类型转换
    //以上两句均可以使用C语言的强转来进行，但C语言的强转是不安全的，尽量使用C++的四种类型转换。
    return 0;
}

3.6函数返回类型不同

3.6.1以值的形式返回（会构建将亡值）

Int fun(int x)
{
	Int tmp(x);
	return tmp;
}
const Int func(int x)
{
	Int tmp(x);
	return tmp;
}
int main()
{
    Int a=fun(1);//ok,编译器进行优化，直接构建a对象
    Int& b=fun(2);//error,fun(2)是一个右值不能以左值引用引用
    const Int& c=fun(3);//ok,左值常引用，可以引用右值
    Int&& d=fun(4);//ok,右值引用引用右值
    const Int&& e=fun(5);//ok,右值常引用
    
    Int a=func(1);//ok,编译器进行优化，直接构建a对象，且该对象不具有常性
    a.SetValue(100);//ok
	a.PrintValue();//ok
    Int& b=func(2);//error,fun(2)是一个右值不能以左值引用引用
    const Int& c=func(3);//ok,左值常引用，可以引用常性右值
    Int&& d=func(4);//error,右值引用不能引用常性右值
    const Int&& e=func(5);//ok,右值常引用
    //对于常性右值引用，编译器编译时将其看成常性左值引用
    return 0;
}

3.6.2以左值引用的形式返回（及其不安全）

Int& fun(int x)
{
    Int tmp(x);
    return tmp;
}
int main()
{
    Int a=fun(1);//编译正确
    Int& b=fun(2);//编译正确
    const Int& c=fun(3);//编译正确
    Int&& d=fun(4);//error,不能使用左值引用初始化右值引用
    cout<<"main end"<<endl;
    return 0;
}

不安全的原因：不能将函数的局部对象或者局部变量以引用的形式返回。引用本质上是指针，在以引用返回时不会构建将亡值，而是直接将tmp对象的地址返回，返回结束后fun函数的栈空间被系统收回，tmp对象已经消亡，用已经消亡的对象去初始化a对象或者引用已死亡的对象是错误的，此时的引用b和c都是失效引用。

3.6.3以右值引用的形式返回（依然不安全）

Int&& fun(int x)
{
    return Int(x);
}
int main()
{
    Int a=fun(1);//ok
    Int& b=fun(2);//error,左值引用不能被右值引用初始化
    const Int& c=fun(3);//ok
    Int&& rf=fun(4);//ok
    a.PrintValue();//ok
    //b.PrintValue();
    c.PrintValue();//ok
    rf.PrintValue();//ok
    return 0;
}

 

 

a对象是以已经死亡的对象构建的，c、rf均引用已死亡的对象

3.6.4安全的以引用返回

当对象的生存期不受函数生存期的影响就可以以引用返回。例如：静态变量

Int& fun(int x)
{
    static Int tmp(x);
    return tmp;
}
void add()
{
    int ar[10]={1,2,3,4,5,6,7,8,9,10};
}
int main()
{
    Int a=fun(1);
    Int& b=fun(2);
    const Int& c=fun(3);
    a.PrintValue();
    b.PrintValue();
    c.PrintValue();
    add();
    b.PrintValue();
    c.PrintValue();
    cout<<"main end"<<endl;
    return 0;
}

 全是1的原因是：静态对象只创建一次当程序结束才消亡。当第一次调用fun(1)函数时，静态对象tmp被创建并初始化为1，在返回时拷贝构造了a对象；当第二次调用fun(2)函数时，静态对象tmp在第一调用中已经创建好了不会再被创建，所以其值依然为1，并且b作为静态对象tmp的引用；同样的，c也作为其引用，所以值均为1。由于静态对象在.data区中，在调用add()函数后不会清扰tmp的数据，所以值依然为1。