菜鸟笔记
提升您的技术认知

c 左值 右值-ag真人游戏

定义

早期的c给出的定义:左值是一个表达式,可能出现在赋值操作的左边或右边,但右值只能出现在右边。比如:

a * b = 42; // 编译错误, 说明 a * b 不是左值

因为上面的定义实在太模糊,导致左值和右值很难被理解,下面给出的定义,更简单更好理解:
左值(lvalue)是一个表达式,它表示一个可被标识的(变量或对象的)内存位置,并且允许使用&操作符来获取这块内存的地址。如果一个表达式不是左值,那它就被定义为右值。

  int i = 42;
  i = 43; 
  int* p = &i; // ok, i 是左值
  int& foo();
  foo() = 42; // ok, foo() 是左值
  int* p1 = &foo(); // ok, foo() 是左值
  int foobar();
  int j = 0;
  j = foobar(); // ok, foobar() 是右值
  int* p2 = &foobar(); // 错误,不能获取右值的地址
  j = 42; // ok, 42 是右值

左值和右值之间的转换

一般上讲,对象之间的运算,对象是以右值的形式参与的。比如二元运算符 两边的参数以右值传入,加后的返回结果也是右值:

int a = 1;     // a 是左值
int b = 2;     // b 是左值
int c = a   b; // a和b自动转换为右值求和

那些表示数组、函数和非完整类型的左值是不能转换为右值的,因为无法对那些类型进行求值。incomplete types指的是类型定义不完整,只能用指针形式声明的类型,在头文件中经常会使用。

左值引用

c 中可以使用&符定义引用,如果一个左值同时是引用,就称为“左值引用”,如:

std::string s;
std::string& sref = s;  //sref为左值引用

非const左值引用不能使用右值对其赋值

std::string& r = std::string(); //错误!std::string()产生一个临时对象,为右值

假设可以的话,就会遇到一个问题:如何修改右值的值?因为引用是可以后续被赋值的。根据上面的定义,右值连可被获取的内存地址都没有,也就谈不上对其进行赋值。

但const左值引用不一样,因为常量不能被修改,也就不存在上面的问题:

const std::string& r = std::string(); //可以

我们经常使用const左值引用作为函数的参数类型,可以减少不必要的对象复制:

class mystring {
public:
    ...
    mystring &mystring(string& s);  //参数类型为左值引用
    ...
};
int main() 
{
    mystring s1("xxx");  //错误
    mystring s2(string("xxxx")); //同上,右值不能赋值给左值引用
}

mystring& mystring(string& a);改成mystring& mystring(const string& a);就不会有上面的编译错误。

带cv限定符(cv-qualified)的右值

c 标准中关于左值转右值的讨论,有这样一段话:

类型为t的左值(非函数、非数组类型)可以被转换为右值。如果t不是类(class)类型,转换后的右值的类型将为不带cv限定符的t类型,否则转换后的右值的类型为t。

什么是cv限定符?如果变量声明时类型前带有const或volatile,就说此变量类型具有cv限定符。

在c中,右值永远没有cv限定符,而c 中的类类型的右值可以有cv限定符,看下面代码:

#include 
class a {
public:
    void foo() const { std::cout << "a::foo() const\n"; }
    void foo() { std::cout << "a::foo()\n"; }
};
a bar() { return a(); }           //返回临时对象,为右值
const a cbar() { return a(); }    //返回带const的右值(带cv限定符)
int main()
{
    bar().foo();  // 非const对象调用a::foo()的非const版本
    cbar().foo(); // const对象调用a::foo()的const版本

也就是说,如果是类类型,从左值转为右值时,它的cv限定符会被保留。这里就不给出示例代码了。

右值引用(c 11)

右值引用及其相关的move语义是c 11新引入的最强大的特性之一。前文说到,左值(非const)可以被修改(赋值),但右值不能。但c 11引入的右值引用特性,打破了这个限制,允许我们获取右值的引用,并修改之。让我们先看点代码:
定义一个类intvec及其赋值操作符重载函数如下:

class intvec
{
public:
    ...
    intvec& operator=(const intvec& other)
    {
        log("copy assignment operator");
        intvec tmp(other);  //构造一个临时对象,因为other为const,不能被修改
        std::swap(m_size, tmp.m_size);
        std::swap(m_data, tmp.m_data);  
        //跟临时对象交换值,临时对象晰构时会delete [] m_data
        return *this;
    }
private:
    size_t m_size;  
    int* m_data;     //存放int数组,构造时动态分配
};  

代码要点:

代码使用了copy-swap策略,即先分配资源再更改自身状态,这样可以保证当资源分配失败的时候,自身能够维持原先状态,《高效c 》有条规则描述这个主题。所以先根据other拷贝构造一个临时对象tmp, 然后与tmp进行swap,m_data交换给了tmp之后,也会随着tmp的晰构而被释放。

之所以把other声明为const,有两个理由,其一是赋值操作不应该更改other,其二是可以传入一个右值。其实这样的声明随处可见。

假设现有类型为intvec的对象v,用一个新对象给它赋值:

v = intvec(33);

这句代码合法,它构造一个临时对象,为右值,传入到intvec的赋值运算符重载函数中。这个代码是可以工作,而且通常情况下都比较高效。但是如果intvec里包含某些m_handle成员,创建和释放m_handle比较昂贵,那么拷贝构造越少越好。这种情况,我们设想一下,如果v能跟intvec(33)临时对象直接进行内部数据交换,而不需要在重载函数里使用intvec tmp(other);构造一个新对象出来swap,那该有多好!
如你所料,c 11引入的“右值引用”和“move语义”就可以实现这个目标,新的语法很简单,我们重载一个新的赋值操作运算符函数:

intvec& operator=(intvec&& other)
{
    log("move assignment operator");
    std::swap(m_size, other.m_size);
    std::swap(m_data, other.m_data);
    return *this;
}

对于v = intvec(33);这种写法就会调用此版本的重载函数(即传入一个右值)。
&&语法声明右值引用,表示一个指向右值的引用,通过这个引用,可以修改右值。

以上就是关于右值引用的一个简单的示例,实际上右值引用是一个复杂的主题,在实际应用中还有很多场景要考虑,更深入的讲解见底部参考链接。

网站地图