注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

数据挖掘

学习数据挖掘

 
 
 

日志

 
 

/C++的左值和右值 收藏  

2012-04-08 13:42:22|  分类: C++基本技巧 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
原文地址:


左值性(lvalueness)在C/C++中是表达式的一个重要属性。只有通过一个左值表达式才能 
来引用及更改一个对象(object)的值。(某些情况下,右值表达式也能引用(refer)到某一 
个对象,并且可能间接修改该对象的值,后述)。 

  何谓对象?如果没有明确说明,这里说的对象,和狭义的类/对象(class/object)相比, 
更为广泛。在C/C++中,所谓的对象指的是执行环境中一块存储区域(a region of storage), 
该存储区域中的内容则代表(represent)了该对象的值(value)。注意到我们这里所说的"代 
表",对于一个对象,如果我们需要取出(fetch)它的值,那么我们需要通过一定的类型(type)来引用它。
使用不同的类型,对同一对象中的内容的解释会导致可能得到不同的值,或者产生某些未定义的行为。 
   在介绍左值之前,我们还需要引入一个概念: 变量(variable)。经常有人会把变量与对 
象二者混淆。什么叫变量?所谓变量是一种声明,通过声明,我们把一个名字(name)与一 
个对象对应起来,当我们使用该名字时,就表示了我们对该对象进行某种操作。但是并不 
是每个对象都有名字,也并不意味着有对应的变量。比如临时对象(temporary object)就 
没有一个名字与之关联(不要误称为临时变量,这是不正确的说法)。 

1 C中的左值  

1.1 
  按照C的定义,左值是一个引用到对象的表达式,通过左值我们可以取出该对象的值。通 
过可修改的左值表达式(modifiable lvalue)我们还可以修改该对象的值。(需要说明的是, 
在C++中,左值还可以引用到函数,即表达式f如果引用的是函数类型,那么在C中它既不是 
左值也不是右值;而在C++中则是左值)。因为左值引用到某一对象,因此我们使用&对左 
值表达式(也只能对左值表达式和函数)取址运算时,可以获得该对象的地址(有两种左 
值表达式不能取址,一是具有位域( bit-field )类型,因为实现中最小寻址单位是 byte; 
另一个是具有register指定符,使用register修饰的变量编译器可能会优化到寄存器中). 

Ex1.1  
  char a[10];  // a is an lvalue representing an array of 10 ints. 
  char (* p)[10]=&a; // &a is the address of the array a. 
  const char* p="hello world"; //"hello world" is an lvalue of type char[12] 
                               //in C,  type const char[12] in C++. 
  char (*p)[12]=&"hello world"; 
   
  struct S{ int a:2; int b: 8; }; 
  struct S  t; 
  int* p=&t.a; //error. t.a is an lvalue of bitfield. 
   
  register int i; 
  int * p=&i; //error. i is an lvalue of register type. 
  int a, b; 
  int * p=& (a+b); //error. a+b is not an lvalue. 

1.2 
  假设expr1是一个指向某对象类型或未完整类型(incomplete type,即该类型的布局和大 
小未知)的指针,那么我们可以断言*expr1一定是个左值表达式,因为按照*运算符的定义, 
*expr1表示引用到expr1所指向的对象。如果expr1是个简单的名字,该名字代表一个变量. 
同样的,该表达式也是个左值,因为他代表的是该变量对应的对象。对于下标运算符,我 
们一样可以做出同样的结论,因为expr1[expr2]总是恒等于*( ( expr1 )+ expr2 ),那么 
p->member,同样也是一个左值表达式。然而对于expr1.expr2,则我们不能断定就是个左值 
表达式。因为expr1可能不是左值。 
  需要特别说明的是,左值性只是表达式的静态属性,当我们说一个表达式是左值的时候, 
并不意味着它一定引用到某一个有效存在的对象。int *p; *p是左值表达式,然而这里对 
*p所引用的对象进行读写的结果将可能是未定义的行为。 
Ex1.2  
      extern struct A a; 
      struct A* p2= &a; 

a是个左值表达式,因而可以进行&运算,然而此时stru A仍然没有完整。 

      //In C++ 
      extern class A a; 
 A & r=a;// OK. Refers to a, though a  with an incomplete type. 

1.3可修改的左值 
   在语义上需要修改左值对应的对象的表达式中,左值必须是一个可修改的左值。比如赋 
值(包括复合赋值)表达式中的左操作数,必须是一个可修改的左值表达式;自增/减运算 
符的操作数等。 
Ex1.3  
      const int a[2], i; //NOTE: a unintialized. legal in C, illegal in C++. 
      i++; //error, i is an lvalue of type const int. 
      a[0]--;//error, a[0] is an lvalue of const int. 

1.4右值 
   与左值相对应的另一个概念是右值(rvalue)。在C中,右值也用表达式的值(value of  
the expression)来表达。即右值强调的不是表达式本身,而是该表达式运算后的结果。这 
个结果往往并不引用到某一对象,可以看成计算的中间结果;当然它也可能引用到某一对 
象,但是通过该右值表达式我们不能直接修改该对象。 

1.4.1右值的存储位置 
Ex1.4       
     int i; 
     i=10; 
10在这里是一个右值表达式,上句执行的语义是用整型常量10的值修改i所引用的对象。 
从汇编语言上看,上述语句可能被翻译成:  
    mov addr_of_i,10; 
10这个值被硬编码到机器指令中; 

右值也可以存储在寄存器中:  
    int i,j,k; 
    k=i+j; 
i+j表达式是个右值,该右值可能存储在寄存器中。 
mov eax, dword ptr[addr_of_i]; 
mov ebx, dword ptr[addr_of_j]; 
add eax, ebx; 
mov dword ptr[addr_of_k], eax; 
在这里,i+j表达式的结果在eax中,这个结果就是i+j表达式的值,它并不引用到某一对象 

某些情况下,一个右值表达式可能也引用到一个对象。 
struct S{ char c[2];}; 
struct S f(void); 

void g() 
f().i; 
f().c[1];  // (*) 
   f()表达式是个函数调用,该表达式的类型是f的返回类型struct S,f()表达式为右值表 
达式,但是在这里往往对应着一个对象,因为这里函数的返回值是一个结构,如果不对应着 
一个对象(一片存储区域),用寄存器几乎不能胜任,而且[]操作符语义上又要求一定引用 
到对象。 
  右值虽然可能引用到对象,然而需要说明的是,在右值表达式中,是否引用到对象及引用 
得对象的生存期往往并不是程序员所能控制。 

1.4.2 
  为什么需要右值?右值表示一个表达式运算后的值,这个值存储的地方并没有指定;当我 
们需要一个表达式运算后的值时,即我们需要右值。比如在赋值运算时,a=b;我们需要用表 
达式b的值,来修改a所代表的对象。如果b是个左值表达式,那么我们必须从b所代表的对象 
中取出(fetch)该对象的值,然后利用该值来修改a代表的对象。这个取出过程,实际上就是 
一个由左值转换到右值的过程。这个过程,C中没有明确表述;但在C++中,被明确归纳为标 
准转换之一,左值到右值转换(lvalue-to-rvalue conversion)。回头看看上面的代码,i+j 
表达式中,+运算符要求其左右操作数都是右值。行1和2,就是取出左值表达式i,j的对应的 
对象的值的过程。这个过程,就是lvalue-to-rvalue conversion。i+j本身就是右值,这里 
不需要执行lvalue-to-rvalue conversion,直接将该右值赋值给k。 

1.4.3右值的类型  
   右值表达式的类型是什么? 在C中,右值总是cv-unqualified的类型。因为我们对于右值, 
即使其对应着某个对象, 我们也无从或不允许修改它。而在C++中,对于built-in类型的右 
值,一样是cv-unqualified,但是类类型(class type)的右值,因为C++允许间接修改其对 
应的对象,因此右值表达式与左值一样同样有cv-qualified的性质。(详细见后) 
Ex1.5    
void f(int); 
void g() 
   const int i; 
   f(i); //OK. i is an lvalue.After an lvalue-to-rvalue conversion, the rvalue's 
                                 //type is int. 

1.5 
   在理解了左值和右值的概念后,我们就能够更好理解为什么有些运算符需要右值,而某些场合则需要左值。简单说来,当操作符的某个操作数是一个表达式,而我们只需要该表达 
式的值时,如果该表达式不是右值,那么我们需要取出该表达式的值;比如算术运算中, 
我们只需要左右操作数的值,这个时候对左右操作数的要求就是右值。任何用作其操作数 
的左值表达式,都需要转化为右值。如果我们需要的不是该表达式的值,而是需要使用表 
达式的其他信息;比如我们只是关心表达式的类型信息,比如作为sizeof的操作数,那么 
我们对表达式究竟是左值还是右值并不关心,我们只需要得到他的类型信息。(按,在 
C++中,表达式的类型信息也有静态、动态之分,这个情况下,表达式的左值性,也会影响 
到一些操作符的语义。比如typeid,后有分析)。有些操作符则必需要求其操作数是左值, 
因为他们需要的是该表达式所引用对象的信息,比如地址;或者希望引用或修改该对象的 
值,比如赋值运算。 
   
  根据分析,我们可以总结出哪些表达式在C中是左值,而哪些操作符又要求其操作数是左 
值表达式: 

表1:左值表达式  (From C  Reference Manual  ) 
-------------------------------------------------- 
表达式              |            条件            | 
__________________________________________________ 
        Name         |        Name 为变量名       | 
-------------------------------------------------- 
      E[k]           |            \               | 
--------------------------------------------------  
(e) //括号表达式    |      e 为左值              | 
--------------------------------------------------   
     e.name          |      e 为左值              | 
-------------------------------------------------- 
     e->name         |         \                  | 
-------------------------------------------------- 
       *e            |         \                  | 
-------------------------------------------------- 
string literal(字符串字面值) |     \            |  
-------------------------------------------------- 

   这里的左值表达式在前面有得已经说明。只说明一下其余的几个表达式,e.name,如果 
e是左值,e.name表示引用对象e中的成员name,因而也是左值;括号表达式不改变e的意义, 
因而不影响他的左值性。另外函数调用(function call)表达式总是右值的。需要特别强调 
的是string literal,前面已经说明它是左值,在C中具有类型char [N],而在C++中类型则 
为const char[N]. C中之所以为char [N]类型,主要是保持向前兼容。C++中的左值表达式 
要更为复杂,但是C中左值表达式,在C++中依然是左值的。  

1.5.1    
   要求操作数为左值的操作符有:&(取址运算)(其操作数也可以是函数类型);++/--: 
赋值表达式的左操作数。另外还有一点需要提及的,在数组到指针转换(array-to-pointer  
conversion )中, C89/90中要求数组必须是左值数组才能执行该转换。 
Ex1.6    
      char c[2];  
      c[0]; //  
   c[0]相当于*(?+0); 然后表达式c从char[2]类型的左值转换为一个char*的右值,该 
右值代表了数组首元素的地址; 

Ex1.7    

struct S{ char c[2]; } f(void);  
void g() 
f().c[0]; 
f().c[0]=1; (*) 

  表达式f().c[0]相当于*( (f().c)+0 ),然而在这里f().c是一个右值数组,在C89/90中, 
因此上述表达式是非法的;而在C99中,array to pointer conversion已经不要求是左值 
数组,上述表达式合法。另外,在这里f()虽然是右值,但是f()却引用到一个对象,我们 
通过f().c[0]左值表达式可以引用到该对象的一部分,并且通过(*)可以修改它(因为该 
左值表达式是modifiable lvalue,但是尝试修改它的行为是未定义的,然而从左右值性上 
是行得通的 ) 

* 关于数组类型 
   数组类型在大部分场合都会退化为一个指向其首元素的指针(右值),因而在左右值性 
和类型判断上,容易发生误解。数组不发生退化的地方有几个场合,一是声明时;一是用 
作sizeof的操作数时;一是用作&取址运算的操作数时。 
Ex1.8    

   int a[3]={1,2,3}; 
   int b[3]; 
   b=a; //error. b converted to int* (rvalue): array degration. 
   int* p=a; //array degration: a converted to an rvalue of int* 
   sizeof(a); // no degration. 
   &a; //no degration. 

   C++中,数组还有其他场合不发生退化,比如作为引用的initializer;作为typeid/ 
typeinfo的操作数和模板推导时。 
2 C++的左值  

 2.1  

 与C不同的是,C++中,一个左值表达式,不仅可以引用到对象,同样也可以引用到一个 
函数上。假定f是一个函数名,那么表达式f就表示一个左值表达式,该表达式引用到对应 
的函数;void (*p)(void); 那么*p也是一个左值。然而一个函数类型的左值是不可修改 
的。 *p=f;// error. (注:类的non-static member function,不是这里指的函数类型, 
它不能脱离对象而存在; 而static member function是函数类型) 
 另一个不同之处在于,对于register变量,C++允许对其取址,即register int i; &i;  
这种取址运算,事实上要求C++编译器忽略掉register specifier指定的建议。无论在C/C++中, register与inline一样都只是对编译器优化的一个建议,这种建议的取舍则由编译器决定。 
 C++中,一个右值的class type表达式,引用到一个对象;这个对象往往是一个临时对象 
(temporary object)。在C++中,我们可以通过class type的右值表达式的成员函数来间 
接修改对象。  

Ex2.1  
class A 
int i,j; 
public: 
void f(){ i=0; } 
void g() const { i; } 
}; 

A foo1(); 
const A foo2(); 

A().f(); //ok, modify the temporary object. 
A().g();//ok, refer to the temporary object. 

foo1().f();//ok, modify the temporary object. 
foo1().g();//ok, refer to the temporary object. 

typedef const A B; 
B().f(); //error. B()' s an rvalue with const A,  
B().g(); //ok, refer to the temporary object. 

foo2().f();//error. B()' s an rvalue with const A, 
foo2().g();//ok, refer to the temporary object 

 需要再次说明的是,C++中的class type的右值表达式可以具有const/volatile属性,而 
在C中右值总是cv-unqualified。 
Ex2.2  
struct A{ char c[2]; }; 
const struct A f(); 
在C中,f()的返回值总是一个右值表达式,具有struct A类型(const被忽略)。 

2.2  
 C++中引入了引用类型(reference type),引用总是引用到某一对象或者函数上,因此当 
我们使用引用时,相当于对其引用的对象/函数进行操作,因而引用类型的表达式总是左值。 
(在分析表达式类型时,如果一个表达式expr最初具有T&类型,该表达式会被看作具有类型 
T的左值表达式) 
Ex2.3  
extern int& ri; 
int & f(); 

int g(); 
f()=1; 
ri=1; 
g()=1;// error. 
函数调用f()的返回类型为int&, 因此表达式f()的类型等价于一个int类型的左值表达式。 
而函数调用g()的返回类型为int,因此表达式g()为int类型的右值表达式。 

与C++相比,C中函数调用的返回值总是右值的。 

2.3  
 与C相比,在C++中,转换表达式可能产生左值。如果转换的目标类型为引用类型T&,转 
换表达式的结果就是一个类型T的左值表达式。 
Ex2.4  
struct base{ //polymorphic type 
int i; 
virtual f() { }// do nothing; 
}; 

struct derived: base { 
}; 

derived d; 
base b; 
dynamic_cast<base&>(d).i=1; // dynamic_cast yields an lvalue of type base. 
dynamic_cast<base>(d); //yields an rvalue of type base. 
static_cast<base&>(d).i=1; // 

( (base&)d ).i=1;
 2.4  

对于member selection表达式E1.E2,C++则比C要复杂的多。 

A)如果E2表达式类型是T&,那么表达式E1.E2也是一个T的左值表达式。 
B)如果E2不是引用类型的话,但是一个类型T的static 成员(data/function member), 
那么E1.E2也将是一个T的左值表达式,因为E1.E2实际上引用到的是一个static成员,该成 
员的存在与否与E1的左值性没有关系。 
C)如果E1是左值,且E2是数据成员(data member),那么E1.E2 是左值,引用到E1所代表 
的对象的相应的数据成员。 
Ex2.5  

struct A{ 
public: 

static int si; 
static void sf(); 

int i; 
void f(); 
int & ri; 
}; 

extern A a; 

A g(); 

void test() 
void (*pf1)()=&a.sf; //a.sf is an lvalue of function type, refers to A::sf. 
void (*pf2)()=&a.f; //error. a.f is not an lvalue and types mismatch. 

g().ri=1; //ok. g().ri is a modifiable lvalue, though g() is an rvalue. 
g().si=1; //ok. Refers to A::si; 
g().i=1; //error. g().i is an rvalue. 

a.i=1; //ok. a is an lvalue. 


对于E1->E2,则可以看成(*E1).E2再用上述方式来判断。 

对于表达式E1.*E2, 在E1是左值和E2是一个指向数据成员的指针的条件下,该表达式是左 
值。 
对于E1->*E2,可以看作(*E1).*E2。在E2是一个指向数据成员的指针的条件下,该表达式 
是左值。 

2.5  

与C相比,C++中前缀++/--表达式、赋值表达式都返回左值。 
逗号表达式的第二个操作数如果是左值表达式的话,逗号表达式也是左值表达式。 
条件表达式(? :)中,如果第2和第3个操作数具有相同类型,那么该条件表达式的结果也是 
左值的。 
Ex2.6  

int i,j; 
int & ri=i; 
int* pi=&(i=1); //ok, i=1 is an modifiable lvalue referring to i; 
++++i; //ok. But maybe issues undefined behavior because of the constraints 
 //about sequence points. 

(i=2, j) =1; //ok 
( ( I==1 ) ? ri : j ) = 0; //ok 

需要当心的是,因为这种修改,在C中well-formed的代码,在C++中可能会产生未定义行为; 
另一方面会造成在C/C++中即使都是well-formed的代码,也会产生不同的行为。 
Ex2.7  
 int i, j; 
 i=j=1; //well formed in C, maybe undefined in C++. 

 char array[100]; 
 sizeof(0, array); 

在C中,sizeof(0, array) == sizeof(char*)。而在C++中,sizeof(0, array)== 100; 

2.6  

typeid表达式总是左值的。 

2.7  

C++中需要左值的场合: 
1) 赋值表达式中的左操作数,需要可修改的左值; 
2) 自增/减中的操作数; 
3) 取址运算中的操作数,需要左值(对象类型,或者函数类型),或者qualified id。 
4) 对于重载的操作符来说,因为执行的是函数的语义,该操作符对于操作数的左值性要 
求、该操作符表达式的类型和左值性, 均由其函数声明决定。 

2.8  

左值性对程序行为的影响: 

2.8.1  

 表达式的左值性对于程序的行为有重要的影响。如果一个需要(可修改)左值的场合, 
而没有对应的符合要求的左值,程序将是ill-formed;反之,如果需要一个右值的话,那 
么一个左值表达式就需要通过lvalue-to-rvalue conversion,转换为一个右值。 
 一个需要左值,或仅仅需要表达式的静态类型信息,而不关心表达式的左值性的场合,则 
往往抑制了在左值表达式上的一些标准转换;而对于需要右值的场合,一个左值表达式往往 
需要经过函数-指针转换、数组-指针转换和左右值转换等。 
Ex2.8  
 char c[100]; 
 char (&rarr)[100]=c; // suppresses array-to-pointer conversion on c. 
 char* p1=c; //c will be adjusted to type "char *". 
 void f(); 
 void (&rf)()=f; //suppresses function-to-pointer conversion on expression f  
 void (*pf)()=f; //f will be adjusted to type "pointer to function  
 //type void () ". 
 sizeof(0, c); // the expression's value is sizeof(char*) in c; 
 //100 in C++, since the expression (0,c) is an lvalue  
 //in C++. 

2.8.2  

除此之外,有些场合无论左右值都可接受,但是根据表达式的左右值性,执行不同的行为: 
Ex2.9  

typeid's behavior 

class B{ public: virtual f() { } }; //polymorphic type. 
class A {}; 
B& foo(); 

typeid(foo()); // foo() is an lvalue of a polymorphic type. Runtime check. 
typeid(A()); //rvalue, statically 
typeid(B()); //rvalue, statically 

A a; 
typeid(a); //lvalue of a non-polymorphic type, statically. 

//.......................... 
reference's behavior 

class C{ private: C(const C&); };//NOTICE 

extern C c; 
C g(); 

C& rc1=c; //bind directly. (1) 
C& rc2=g()//error. (2) 
const C& r2=g(); //error. (3) 

这里表达式c是个左值表达式,且其类型(C)与rc1的类型兼容,因此(1)式直接绑定; 
而(2)和(3)中,右边的表达式均为右值表达式,且该右值表达式又不能通过user  
conversion转换成与左边的变量兼容的类型,因此语义上这里需要构造一个临时对象,并 
使用C的构造函数和右值g()来初始化它,但是这里的C的拷贝构造函数(copy ctor)又不可 
访问,因此以上声明语句非法。
 

  评论这张
 
阅读(128)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017