左值性（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）又不可访问，因此以上声明语句非法。