这些新类别与现有的右值和左值类别有何关联？

C++03左值仍然是C++11左值，而C++03右值在C++11中称为prvalue。

这些新的表达类别是什么？

FCD（n3092）具有出色的描述：

-左值（历史上称为左值，因为左值可能出现在作业的左侧表达式）指定函数或一个物体。[示例：如果E是指针类型的表达式，则*E是一个左值表达式，表示E所指向的对象或函数点。作为另一个例子，结果调用其返回的函数类型是左值引用是左值-结束示例]-x值（An“eXpiring”值）也指对象，通常在其末端附近生命周期（以便其资源例如移动）。xvalue是某些类型表达式的结果涉及右值参考（8.3.2）[示例：调用返回类型为rvalue引用是一个xvalue-终止示例]-glvalue（“广义”左值）是左值或x值。—右值（历史上称为，因为右值可能出现在作业的右侧表达式）是一个xvalue，一个临时对象（12.2）或其子对象，或与对象-prvalue（“纯”rvalue）为不是xvalue的右值。[示例：调用返回类型不是引用是prvalue。a的值文字，如12、7.3e5或true也是prvalue-结束示例]每一个表达式正好属于中的基本分类此分类法：lvalue、xvalue或prvalue。一个表达式称为其值类别[注：讨论第5条中的每个内置运算符指示其值的类别收益率和价值类别它需要的操作数。例如内置赋值运算符左操作数是左值，并且右操作数是prvalue并作为结果产生左值。用户定义的运算符是函数，以及他们的价值类别预期和收益由以下因素决定它们的参数和返回类型-终止笔记

我建议您阅读整个第3.10节L值和右值。

这些新类别与现有的右值和左值类别有何关联？

再一次：

C++0x中的右值和左值类别是否与C++03中的相同？

右值的语义随着移动语义的引入而不断发展。

为什么需要这些新类别？

以便定义和支持移动构造/分配。

引言

ISOC++11（正式的ISO/IEC 14882:2011）是C++编程语言标准的最新版本。它包含一些新功能和概念，例如：

右值引用xvalue、glvalue、prvalue表达式值类别移动语义

如果我们想理解新表达式值类别的概念，我们必须知道有右值和左值引用。最好知道右值可以传递给非常值右值引用。

int& r_i=7; // compile error
int&& rr_i=7; // OK

如果我们引用N3337工作草案（与已发布的ISOC++11标准最相似的草案）中标题为Lvalues和rvalues的小节，我们可以获得价值类别概念的一些直觉。

3.10 L值和R值[基本值]1表达式根据图1中的分类法进行分类。左值（历史上称为左值，因为左值可能出现在赋值表达式的左侧）表示函数或物体。[示例：如果E是指针类型的表达式，则*E是指E指向的对象或函数的左值表达式。作为另一个示例，调用函数的结果其返回类型为左值引用的值为左值-结束示例]xvalue（“eXpiring”值）也指的是一个对象，通常在其生命周期结束时（这样它的资源就可以移动，例如示例）。xvalue是某些类型表达式的结果涉及右值引用（8.3.2）。[示例：调用返回类型为右值引用的函数为xvalue-终止示例]glvalue（“广义”左值）是左值或x值。右值（历史上称为，因为右值可能出现在赋值表达式的右侧）是一个xvalue，一个临时对象（12.2）或其子对象，或不是与对象关联。prvalue（“纯”右值）是一个不是xvalue的右值。[示例：调用返回类型不是引用是prvalue。文字的值，例如12、7.3e5或true也是prvalue-结束示例]每个表达式都属于此分类法中的分类：lvalue、xvalue或prvalue。这表达式的属性称为其值类别。

但我不太确定这一小节是否足以清楚地理解这些概念，因为“通常”不是很一般，“接近其生命周期结束时”不是很具体，“涉及右值引用”也不是很清楚，“示例：调用返回类型为右值引用的函数的结果是一个xvalue”听起来像蛇在咬尾巴。

主要价值类别

每个表达式都属于一个主值类别。这些值类别是lvalue、xvalue和prvalue类别。

左值

表达式E属于左值类别，当且仅当E指的是一个实体，该实体的身份（地址、名称或别名）使其可以在E之外访问。

#include <iostream>

int i=7;

const int& f(){
    return i;
}

int main()
{
    std::cout<<&"www"<<std::endl; // The expression "www" in this row is an lvalue expression, because string literals are arrays and every array has an address.  

    i; // The expression i in this row is an lvalue expression, because it refers to the same entity ...
    i; // ... as the entity the expression i in this row refers to.

    int* p_i=new int(7);
    *p_i; // The expression *p_i in this row is an lvalue expression, because it refers to the same entity ...
    *p_i; // ... as the entity the expression *p_i in this row refers to.

    const int& r_I=7;
    r_I; // The expression r_I in this row is an lvalue expression, because it refers to the same entity ...
    r_I; // ... as the entity the expression r_I in this row refers to.

    f(); // The expression f() in this row is an lvalue expression, because it refers to the same entity ...
    i; // ... as the entity the expression f() in this row refers to.

    return 0;
}

x值

表达式E属于xvalue类别，当且仅当它是

-调用函数（无论是隐式还是显式）的结果，该函数的返回类型是对所返回对象类型的右值引用，或

int&& f(){
    return 3;
}

int main()
{
    f(); // The expression f() belongs to the xvalue category, because f() return type is an rvalue reference to object type.

    return 0;
}

-对对象类型的右值引用的强制转换，或

int main()
{
    static_cast<int&&>(7); // The expression static_cast<int&&>(7) belongs to the xvalue category, because it is a cast to an rvalue reference to object type.
    std::move(7); // std::move(7) is equivalent to static_cast<int&&>(7).

    return 0;
}

-指定非引用类型的非静态数据成员的类成员访问表达式，其中对象表达式是xvalue，或

struct As
{
    int i;
};

As&& f(){
    return As();
}

int main()
{
    f().i; // The expression f().i belongs to the xvalue category, because As::i is a non-static data member of non-reference type, and the subexpression f() belongs to the xvlaue category.

    return 0;
}

-指向成员的指针表达式，其中第一个操作数是一个xvalue，而第二个操作数则是指向数据成员的指针。

注意，上述规则的效果是，对象的命名右值引用被视为左值，对象的未命名右值参考被视为xvalue；函数的右值引用被视为左值，无论是否命名。

#include <functional>

struct As
{
    int i;
};

As&& f(){
    return As();
}

int main()
{
    f(); // The expression f() belongs to the xvalue category, because it refers to an unnamed rvalue reference to object.
    As&& rr_a=As();
    rr_a; // The expression rr_a belongs to the lvalue category, because it refers to a named rvalue reference to object.
    std::ref(f); // The expression std::ref(f) belongs to the lvalue category, because it refers to an rvalue reference to function.

    return 0;
}

pr值

表达式E属于prvalue类别，当且仅当E既不属于lvalue类别，也不属于xvalue类别。

struct As
{
    void f(){
        this; // The expression this is a prvalue expression. Note, that the expression this is not a variable.
    }
};

As f(){
    return As();
}

int main()
{
    f(); // The expression f() belongs to the prvalue category, because it belongs neither to the lvalue nor to the xvalue category.

    return 0;
}

混合价值类别

还有两个重要的混合价值类别。这些值类别是rvalue和glvalue类别。

右值

表达式E属于右值类别，当且仅当E属于xvalue类别或prvalue类别。

请注意，此定义意味着表达式E属于右值类别，当且仅当E指的是一个实体，该实体没有任何使其在E YET之外可访问的标识。

gl值

表达式E属于glvalue类别，当且仅当E属于lvalue类别或xvalue类别。

实用规则

Scott Meyer发表了一个非常有用的经验法则来区分右值和左值。

如果可以获取表达式的地址，则该表达式是左值。如果表达式的类型是左值引用（例如，T&或常量T&等），则该表达式是左值。否则，表达式为右值。从概念上（通常也是事实上），右值对应于临时对象，例如作为从函数返回的或通过隐式类型创建的转换。大多数文字值（例如10和5.3）也是右值。

这些是C++委员会用来在C++11中定义移动语义的术语。这就是故事。

我发现很难理解这些术语，因为它们有精确的定义、长长的规则列表或这个流行的图表：

在带有典型示例的Venn图上更容易：

基本上：

每个表达式都是左值或右值必须复制左值，因为它具有标识，所以可以稍后使用可以移动rvalue，因为它是临时的（prvalue）或显式移动的（xvalue）

现在，好问题是，如果我们有两个正交的财产（“有恒等式”和“可以移动”），那么完成左值、xvalue和prvalue的第四个类别是什么？这将是一个没有标识的表达式（因此以后无法访问），并且无法移动（需要复制其值）。这根本没用，所以没有命名。

为什么需要这些新类别？WG21众神只是想迷惑我们这些凡人吗？

我觉得其他的答案（虽然很多都很好）并没有真正抓住这个问题的答案。是的，这些类别的存在是为了允许移动语义，但复杂性的存在有一个原因。这是C++11中移动内容的一条不可侵犯的规则：

只有在毫无疑问安全的情况下，你才能移动。

这就是为什么存在这些类别：能够在安全的地方谈论价值观，而在不安全的地方讨论价值观。

在最早版本的r值引用中，移动很容易发生。太容易了。很容易，当用户不是真的想这样做的时候，就有很大的潜力来隐式移动东西。

以下是移动物品的安全情况：

当它是临时对象或其子对象时。（prvalue）当用户明确表示要移动它时。

如果您这样做：

SomeType &&Func() { ... }

SomeType &&val = Func();
SomeType otherVal{val};

这有什么作用？在较旧版本的规范中，在5个值出现之前，这将引发一个变化。当然了。您向构造函数传递了一个右值引用，因此它绑定到接受右值引用的构造函数。这很明显。

这只是一个问题；你没有要求移动它。哦，你可能会说&&应该是一个线索，但这并不能改变它违反规则的事实。val不是临时的，因为临时人员没有名字。你可能延长了暂时的生命周期，但这意味着它不是暂时的；它就像任何其他堆栈变量一样。

如果这不是暂时的，并且你没有要求移动它，那么移动是错误的。

显而易见的解决方案是使val成为左值。这意味着你不能离开它。好的，好的；它被命名，所以它是一个左值。

一旦你做到了这一点，你就不能再说SomeType&&在任何地方都意味着相同的东西。现在，您已经区分了命名的右值引用和未命名的右值引用。嗯，命名的右值引用是左值；这就是我们上面的解决方案。那么我们怎么称呼未命名的右值引用（上面Func的返回值）呢？

它不是左值，因为你不能从左值移动。我们需要能够通过返回&&；你怎么能明确地说要搬东西？毕竟，这就是std:：move返回的结果。这不是一个右值（老式），因为它可以位于方程的左侧（事实上情况有点复杂，请参阅下面的问题和注释）。它既不是左值，也不是右值；这是一种新事物。

我们所拥有的是一个可以作为左值处理的值，除了它可以从中隐式移动。我们称之为xvalue。

注意，xvalues是我们获得其他两类值的原因：

prvalue实际上只是先前类型的rvalue的新名称，即它们是不是xvalue的rvalues。Glvalues是xvalues和lvalue在一个组中的联合，因为它们确实共享许多共同的财产。

所以，实际上，这一切都归结为xvalue和将移动限制在特定位置的需要。这些地方由右值类别定义；prvalues是隐式移动，xvalues是显式移动（std:：move返回一个xvalue）。

C++03的类别太有限，无法将右值引用正确引入表达式属性。

随着它们的引入，据说未命名的右值引用求值为右值，因此重载解析将倾向于右值引用绑定，这将使其选择移动构造函数而不是复制构造函数。但研究发现，这会导致各种问题，例如动态类型和限定。

要显示这一点，请考虑

int const&& f();

int main() {
  int &&i = f(); // disgusting!
}

在xvalue之前的草稿中，这是允许的，因为在C++03中，非类类型的rvalue永远不会被cv限定。但const适用于右值引用情况，因为这里我们确实引用了对象（=内存！），从非类右值中删除const主要是因为没有对象。

动态类型的问题具有相似的性质。在C++03中，类类型的右值有一个已知的动态类型——它是该表达式的静态类型。因为要以另一种方式实现，您需要引用或解引用，它们的计算结果为左值。对于未命名的右值引用，情况并非如此，但它们可以显示多态行为。为了解决这个问题，

未命名的右值引用变为xvalue。它们可以是限定的，并且可能具有不同的动态类型。它们确实像预期的那样，在重载期间更喜欢右值引用，并且不会绑定到非常值左值引用。以前是一个rvalue（文本，通过对非引用类型的强制转换创建的对象）现在变成了一个prvalue。在重载期间，它们与xvalue具有相同的偏好。以前的左值仍然是左值。

我们进行了两个分组，以捕获那些可以被限定并且可以具有不同动态类型（glvalue）的对象，以及那些重载更喜欢右值引用绑定（rvalues）的对象。