值类别

每个 C++ 表达式（带操作数的运算符、字面量、变量名等）都具有两个独立的属性：类型和 值类别。每个表达式都具有某个非引用类型，并且每个表达式都属于三种主要值类别中的一个：纯右值、将亡值 和左值。

一个泛左值（“泛化”左值）是一个表达式，其求值确定了对象或函数的身份；
一个纯右值（“纯”右值）是一个表达式，其求值

计算内置运算符的操作数的值（这种纯右值没有 结果对象），或者
初始化一个对象（这种纯右值被称为具有 结果对象）。

结果对象可以是变量、由 new 表达式创建的对象、由临时物化创建的临时对象，或其成员。注意，非 void 丢弃表达式具有结果对象（物化的临时对象）。此外，每个类和数组纯右值都具有结果对象，除非它是 decltype 的操作数；

一个将亡值（一个“即将消亡”的值）是一个泛左值，它表示一个可以重用其资源的对象；
一个左值是一个不是将亡值的泛左值；

扩展内容

所以说，在历史上，左值可以出现在赋值表达式的左侧。总的来说，情况并非总是如此

void foo();
 
void baz()
{
    int a; // Expression `a` is lvalue
    a = 4; // OK, could appear on the left-hand side of an assignment expression
 
    int &b{a}; // Expression `b` is lvalue
    b = 5; // OK, could appear on the left-hand side of an assignment expression
 
    const int &c{a}; // Expression `c` is lvalue
    c = 6;           // ill-formed, assignment of read-only reference
 
    // Expression `foo` is lvalue
    // address may be taken by built-in address-of operator
    void (*p)() = &foo;
 
    foo = baz; // ill-formed, assignment of function
}

一个右值是一个纯右值或将亡值；

扩展内容

所以说，在历史上，右值可以出现在赋值表达式的右侧。总的来说，情况并非总是如此

运行这段代码

#include <iostream>
 
struct S
{
    S() : m{42} {}
    S(int a) : m{a} {}
    int m;
};
 
int main()
{
    S s;
 
    // Expression `S{}` is prvalue
    // May appear on the right-hand side of an assignment expression
    s = S{};
 
    std::cout << s.m << '\n';
 
    // Expression `S{}` is prvalue
    // Can be used on the left-hand side too
    std::cout << (S{} = S{7}).m << '\n';
}

输出

42
7

注意：这个分类法随着过去 C++ 标准修订的进行而发生了重大变化，有关详细信息，请参见下面的历史。

扩展内容

尽管它们的名字如此，但这些术语对表达式进行分类，而不是对值进行分类。

运行这段代码

#include <type_traits>
#include <utility>
 
template <class T> struct is_prvalue : std::true_type {};
template <class T> struct is_prvalue<T&> : std::false_type {};
template <class T> struct is_prvalue<T&&> : std::false_type {};
 
template <class T> struct is_lvalue : std::false_type {};
template <class T> struct is_lvalue<T&> : std::true_type {};
template <class T> struct is_lvalue<T&&> : std::false_type {};
 
template <class T> struct is_xvalue : std::false_type {};
template <class T> struct is_xvalue<T&> : std::false_type {};
template <class T> struct is_xvalue<T&&> : std::true_type {};
 
int main()
{
    int a{42};
    int& b{a};
    int&& r{std::move(a)};
 
    // Expression `42` is prvalue
    static_assert(is_prvalue<decltype((42))>::value);
 
    // Expression `a` is lvalue
    static_assert(is_lvalue<decltype((a))>::value);
 
    // Expression `b` is lvalue
    static_assert(is_lvalue<decltype((b))>::value);
 
    // Expression `std::move(a)` is xvalue
    static_assert(is_xvalue<decltype((std::move(a)))>::value);
 
    // Type of variable `r` is rvalue reference
    static_assert(std::is_rvalue_reference<decltype(r)>::value);
 
    // Type of variable `b` is lvalue reference
    static_assert(std::is_lvalue_reference<decltype(b)>::value);
 
    // Expression `r` is lvalue
    static_assert(is_lvalue<decltype((r))>::value);
}

[编辑] 主要类别

[编辑] 左值

以下是左值表达式

变量名称，函数，模板参数对象(自 C++20 起)，或数据成员，无论类型如何，例如 std::cin 或 std::endl。即使变量的类型是右值引用，由其名称组成的表达式也是一个左值表达式（但请参见可移动表达式）；

扩展内容

void foo() {}
 
void baz()
{
    // `foo` is lvalue
    // address may be taken by built-in address-of operator
    void (*p)() = &foo;
}

struct foo {};
 
template <foo a>
void baz()
{
    const foo* obj = &a;  // `a` is an lvalue, template parameter object
}

函数调用或重载运算符表达式，其返回值类型是左值引用，例如 std::getline(std::cin, str)，std::cout << 1，str1 = str2，或 ++it；

扩展内容
int& a_ref() { static int a{3}; return a; } void foo() { a_ref() = 5; // `a_ref()` is lvalue, function call whose return type is lvalue reference }

a = b，a += b，a %= b，以及所有其他内置的赋值和复合赋值表达式；
++a 和 --a，内置的前缀自增和自减表达式；
*p，内置的间接访问表达式；
a[n] 和 p[n]，内置的下标表达式，其中 a[n] 中的一个操作数是数组左值(自 C++11 起)；
a.m，对象成员表达式，除了 m 是成员枚举器或非静态成员函数，或者 a 是右值且 m 是对象类型的非静态数据成员；

扩展内容

struct foo
{
    enum bar
    {
        m // member enumerator
    };
};
 
void baz()
{
    foo a;
    a.m = 42; // ill-formed, lvalue required as left operand of assignment
}

struct foo
{
    void m() {} // non-static member function
};
 
void baz()
{
    foo a;
 
    // `a.m` is a prvalue, hence the address cannot be taken by built-in
    // address-of operator
    void (foo::*p1)() = &a.m; // ill-formed
 
    void (foo::*p2)() = &foo::m; // OK: pointer to member function
}

struct foo
{
    static void m() {} // static member function
};
 
void baz()
{
    foo a;
    void (*p1)() = &a.m;     // `a.m` is an lvalue
    void (*p2)() = &foo::m;  // the same
}

p->m，内置的指针成员表达式，除了 m 是成员枚举器或非静态成员函数；
a.*mp，对象成员指针表达式，其中 a 是左值且 mp 是数据成员指针；
p->*mp，内置的指针成员指针表达式，其中 mp 是数据成员指针；
a, b，内置的逗号表达式，其中 b 是左值；
a ? b : c，三元条件表达式，用于某些 b 和 c（例如，当两者都是相同类型的左值时，但请参见定义获取详细信息）；
一个字符串字面量，例如 "Hello, world!"；
一个转换为左值引用类型的强制转换表达式，例如 static_cast<int&>(x) 或 static_cast<void(&)(int)>(x)；
一个非类型模板参数，其类型为左值引用；

template <int& v>
void set()
{
    v = 5; // template parameter is lvalue
}
 
int a{3}; // static variable, fixed address is known at compile-time
 
void foo()
{
    set<a>();
}

函数调用或重载运算符表达式，其返回值类型为指向函数的右值引用；
一个转换为指向函数的右值引用的强制转换表达式，例如 static_cast<void(&&)(int)>(x)。

(自 C++11 起)

属性

与纯左值（在下文）相同。
左值的地址可以使用内置的地址运算符获取：&++i^[1] 和 &std::endl 是有效的表达式。
可修改的左值可以用作内置的赋值运算符和复合赋值运算符的左侧操作数。
左值可用于初始化左值引用；这会将一个新名称与表达式标识的对象相关联。

[编辑] 纯右值

以下是纯右值表达式

一个字面量（除了字符串字面量），例如 42，true 或 nullptr；
函数调用或重载运算符表达式，其返回值类型是非引用类型，例如 str.substr(1, 2)，str1 + str2，或 it++；
a++ 和 a--，内置的后缀自增和自减表达式；
a + b，a % b，a & b，a << b，以及所有其他内置的算术表达式；
a && b，a || b，!a，内置的逻辑表达式；
a < b，a == b，a >= b，以及所有其他内置的比较表达式；
&a，内置的地址运算符表达式；
a.m，对象成员表达式，其中 m 是成员枚举器或非静态成员函数^[2]；
p->m，内置的指针成员表达式，其中 m 是成员枚举器或非静态成员函数^[2]；
a.*mp，对象成员指针表达式，其中 mp 是指向成员函数的指针^[2]；
p->*mp，内置的指针成员指针表达式，其中 mp 是指向成员函数的指针^[2]；
a, b，内置的逗号表达式，其中 b 是纯右值；
a ? b : c，三元条件表达式，用于某些 b 和 c（请参见定义获取详细信息）；
对非引用类型的强制转换表达式，例如 static_cast<double>(x)、std::string{} 或 (int)42。
this 指针；
一个枚举器；
标量类型的非类型模板参数；

template <int v>
void foo()
{
    // not an lvalue, `v` is a template parameter of scalar type int
    const int* a = &v; // ill-formed
 
    v = 3; // ill-formed: lvalue required as left operand of assignment
}

一个 lambda 表达式，例如 [](int x){ return x * x; }；	(自 C++11 起)
一个 requires-expression，例如 requires (T i) { typename T::type; }；一个概念的特化，例如 std::equality_comparable<int>。	(自 C++20 起)

属性

与右值 (下文) 相同。
纯右值不能是多态的：它所表示的对象的动态类型始终是表达式的类型。
非类非数组纯右值不能是 cv 限定的，除非为了绑定到 cv 限定类型的引用而被具体化(自 C++17 起)。(注意：函数调用或强制转换表达式可能会导致非类 cv 限定类型的纯右值，但 cv 限定符通常会立即被剥离。)
纯右值不能具有不完整类型 (除了类型 void，见下文，或在 decltype 说明符中使用)。
纯右值不能具有抽象类类型或其数组。

[edit] 将亡值

以下表达式是将亡值表达式

a.m，对象成员表达式，其中 a 是一个右值，m 是对象类型的非静态数据成员；
a.*mp, 指向对象成员的指针表达式，其中 a 是一个右值，mp 是指向数据成员的指针；
a, b，内置的逗号表达式，其中 b 是一个将亡值；
a ? b : c，三元条件表达式，用于某些 b 和 c（请参见定义获取详细信息）；

函数调用或重载运算符表达式，其返回类型是对象类型的右值引用，例如 std::move(x)； a[n]，内置的下标表达式，其中一个操作数是数组右值；强制转换表达式，转换为对象类型的右值引用，例如 static_cast<char&&>(x)；	(自 C++11 起)
任何在临时具体化之后，指定临时对象的表达式；	(自 C++17 起)
一个可移动表达式。	(自 C++23 起)

属性

与右值 (下文) 相同。
与左值 (下文) 相同。

特别是，与所有右值一样，将亡值绑定到右值引用；与所有左值一样，将亡值可能是多态的，非类将亡值可能是 cv 限定的。

扩展内容

运行这段代码

#include <type_traits>
 
template <class T> struct is_prvalue : std::true_type {};
template <class T> struct is_prvalue<T&> : std::false_type {};
template <class T> struct is_prvalue<T&&> : std::false_type {};
 
template <class T> struct is_lvalue : std::false_type {};
template <class T> struct is_lvalue<T&> : std::true_type {};
template <class T> struct is_lvalue<T&&> : std::false_type {};
 
template <class T> struct is_xvalue : std::false_type {};
template <class T> struct is_xvalue<T&> : std::false_type {};
template <class T> struct is_xvalue<T&&> : std::true_type {};
 
// Example from C++23 standard: 7.2.1 Value category [basic.lval]
struct A
{
    int m;
};
 
A&& operator+(A, A);
A&& f();
 
int main()
{
    A a;
    A&& ar = static_cast<A&&>(a);
 
    // Function call with return type rvalue reference is xvalue
    static_assert(is_xvalue<decltype( (f()) )>::value);
 
    // Member of object expression, object is xvalue, `m` is a non-static data member
    static_assert(is_xvalue<decltype( (f().m) )>::value);
 
    // A cast expression to rvalue reference
    static_assert(is_xvalue<decltype( (static_cast<A&&>(a)) )>::value);
 
    // Operator expression, whose return type is rvalue reference to object
    static_assert(is_xvalue<decltype( (a + a) )>::value);
 
    // Expression `ar` is lvalue, `&ar` is valid
    static_assert(is_lvalue<decltype( (ar) )>::value);
    [[maybe_unused]] A* ap = &ar;
}

[edit] 混合类别

[edit] 左值

一个左值表达式要么是左值，要么是将亡值。

属性

左值可以通过左值到右值、数组到指针或函数到指针的隐式转换隐式转换为纯右值。
左值可能是多态的：它所标识的对象的动态类型不一定是表达式的静态类型。
左值可以具有不完整类型，只要表达式允许。

[edit] 右值

一个右值表达式要么是纯右值，要么是将亡值。

属性

不能通过内置的取地址运算符获取右值的地址：&int()、&i++^[3]、&42 和 &std::move(x) 无效。
右值不能用作内置赋值运算符或复合赋值运算符的左侧操作数。
右值可以用于初始化 const 左值引用，在这种情况下，右值标识的临时对象的生存期将延长，直到引用的作用域结束。

右值可以用于初始化右值引用，在这种情况下，右值标识的临时对象的生存期将延长，直到引用的作用域结束。
当用作函数参数，并且函数的两个重载可用时，一个采用右值引用参数，另一个采用 const 左值引用参数，右值绑定到右值引用重载（因此，如果复制构造函数和移动构造函数都可用，右值参数将调用移动构造函数，复制赋值运算符和移动赋值运算符也是如此）。

(自 C++11 起)

[edit] 特殊类别

[edit] 待定成员函数调用

表达式 a.mf 和 p->mf, 其中 mf 是一个非静态成员函数，以及表达式 a.*pmf 和 p->*pmf, 其中 pmf 是一个指向成员函数的指针，被归类为纯右值表达式，但它们不能用于初始化引用、作为函数参数，或用于任何其他目的，除了作为函数调用运算符的左侧参数，例如 (p->*pmf)(args)。

[edit] 空表达式

返回 void 的函数调用表达式、强制转换为 void 的强制转换表达式和抛出表达式被归类为纯右值表达式，但它们不能用于初始化引用或作为函数参数。它们可以在丢弃值上下文中使用（例如，单独一行，作为逗号运算符的左侧操作数，等等），以及在返回 void 的函数的 return 语句中。此外，抛出表达式可以用作条件运算符 ?: 的第二个和第三个操作数。

空表达式没有结果对象。

(自 C++17 起)

[edit] 位域

指定位域的表达式（例如，a.m，其中 a 是类型 struct A { int m: 3; } 的左值）是一个左值表达式：它可以用作赋值运算符的左侧操作数，但不能获取其地址，也不能将非 const 左值引用绑定到它。const 左值引用或右值引用可以从位域左值初始化，但将创建一个位域的临时副本：它不会直接绑定到位域。

可移动表达式

尽管由任何变量的名称组成的表达式都是一个左值表达式，但如果该表达式作为以下运算符的操作数出现，则该表达式可能是可移动的

一个 return 语句
一个 co_return 语句 (自 C++20 起)
一个 throw 表达式 (自 C++17 起)

如果一个表达式是可移动的，它被视为一个右值或一个左值(直到 C++23)一个右值(自 C++23 起) 用于重载解析（因此它可以选择移动构造函数）。有关详细信息，请参阅自动从局部变量和参数移动。

(自 C++11 起)

[编辑] 历史

[编辑] CPL

编程语言 CPL 首次引入了表达式的值类别：所有 CPL 表达式都可以以“右手模式”进行评估，但只有某些类型的表达式在“左手模式”下有意义。在右手模式下进行评估时，表达式被视为计算值的规则（右手值，或右值）。在左手模式下进行评估时，表达式实际上给出了一个地址（左手值，或左值）。这里的“左”和“右”分别代表“赋值的左侧”和“赋值的右侧”。

[编辑] C

C 编程语言遵循类似的分类法，除了赋值的作用不再重要：C 表达式在“左值表达式”和其他表达式（函数和非对象值）之间进行分类，其中“左值”表示标识对象的表达式，一个“定位器值”^[4]。

[编辑] C++98

2011 年之前的 C++ 遵循 C 模型，但恢复了“右值”这个名称用于非左值表达式，将函数变成了左值，并添加了规则，即引用可以绑定到左值，但只有对 const 的引用可以绑定到右值。一些非左值 C 表达式在 C++ 中变成了左值表达式。

[编辑] C++11

随着 C++11 中移动语义的引入，值类别被重新定义以表征表达式的两个独立属性^[5]

具有标识：可以确定表达式是否引用与另一个表达式相同的实体，例如通过比较它们标识的对象或函数的地址（直接或间接获得）；
可以从其移动：移动构造函数、移动赋值运算符或实现移动语义的其他函数重载可以绑定到表达式。

在 C++11 中，满足以下条件的表达式：

具有标识且无法从其移动的称为左值表达式；
具有标识且可以从其移动的称为x 值表达式；
不具有标识且可以从其移动的称为纯右值（“pure rvalue”）表达式；
不具有标识且无法从其移动的不会被使用^[6]。

具有标识的表达式称为“广义左值表达式”（glvalue 代表“广义左值”。左值和 x 值都是广义左值表达式。

可以从其移动的表达式称为“右值表达式”。纯右值和 x 值都是右值表达式。

[编辑] C++17

在 C++17 中，复制省略在某些情况下是强制性的，这需要将纯右值表达式与其初始化的临时对象分离，从而产生了我们今天所拥有的系统。请注意，与 C++11 方案相比，纯右值不再从其移动。

[编辑] 脚注

↑ 假设 i 具有内置类型，或者前置递增运算符被重载以返回左值引用。
↑ ^2.0 ^2.1 ^2.2 ^2.3 特殊右值类别，请参阅挂起成员函数调用。
↑ 假设 i 具有内置类型，或者后置递增运算符未被重载以返回左值引用。
↑ “C 社区内部对左值的含义存在分歧，一派认为左值是任何类型的对象定位器，另一派认为左值在赋值运算符的左侧是有意义的。C89 委员会采用了左值作为对象定位器的定义。”—— ANSI C Rationale, 6.3.2.1/10。
↑ "New" Value Terminology by Bjarne Stroustrup, 2010.
↑ const 纯右值（仅允许用于类类型）和 const x 值不会绑定到 T&& 重载，但它们会绑定到 const T&& 重载，它们也被标准归类为“移动构造函数”和“移动赋值运算符”，满足用于此分类的“可以从其移动”的定义。但是，此类重载无法修改其参数，并且实际上不会被使用；在没有这些重载的情况下，const 纯右值和 const x 值会绑定到 const T& 重载。

[编辑] 参考文献

C++23 标准 (ISO/IEC 14882:2024)

7.2.1 值类别 [basic.lval]

C++20 标准 (ISO/IEC 14882:2020)

7.2.1 值类别 [basic.lval]

C++17 标准 (ISO/IEC 14882:2017)

6.10 左值和右值 [basic.lval]

C++14 标准 (ISO/IEC 14882:2014)

3.10 左值和右值 [basic.lval]

C++11 标准 (ISO/IEC 14882:2011)

3.10 左值和右值 [basic.lval]

C++98 标准 (ISO/IEC 14882:1998)

3.10 左值和右值 [basic.lval]

[编辑] 缺陷报告

以下更改行为的缺陷报告被追溯应用于先前发布的 C++ 标准。

DR	应用于	发布时的行为	正确的行为
CWG 616	C++11	成员访问和通过指向成员的指针对右值的访问导致纯右值	重新分类为 x 值
CWG 1059	C++11	数组纯右值无法被 cv 限定	允许
CWG 1213	C++11	对数组右值的索引导致左值	重新分类为 x 值

[编辑] 另请参阅

C 文档 for 值类别

[编辑] 外部链接

1.

C++ 值类别和 decltype 的解惑 — David Mazières, 2021

2.

经验性地确定表达式的值类别 — StackOverflow

[1] 假设 i 具有内置类型，或者前置递增运算符被重载以返回左值引用。

[pmfc-2] 2.0 ^2.1 ^2.2 ^2.3 特殊右值类别，请参阅挂起成员函数调用。

[3] 假设 i 具有内置类型，或者后置递增运算符未被重载以返回左值引用。

[4] “C 社区内部对左值的含义存在分歧，一派认为左值是任何类型的对象定位器，另一派认为左值在赋值运算符的左侧是有意义的。C89 委员会采用了左值作为对象定位器的定义。”—— ANSI C Rationale, 6.3.2.1/10。

[5] "New" Value Terminology by Bjarne Stroustrup, 2010.

[6] st 纯右值（仅允许用于类类型）和 const x 值不会绑定到 T&& 重载，但它们会绑定到 const T&& 重载，它们也被标准归类为“移动构造函数”和“移动赋值运算符”，满足用于此分类的“可以从其移动”的定义。但是，此类重载无法修改其参数，并且实际上不会被使用；在没有这些重载的情况下，const 纯右值和 const x 值会绑定到 const T& 重载。

[1]

[2]

[3]

[4]

[5]

[6]

编译器支持
独立和宿主
语言
标准库
标准库头文件
命名需求
功能测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作

值类别

内容

[编辑] 主要类别

[编辑] 左值

[编辑] 纯右值

[edit] 将亡值

[edit] 混合类别

[edit] 左值

[edit] 右值

[edit] 特殊类别

[edit] 待定成员函数调用

[edit] 空表达式

[edit] 位域

可移动表达式

[编辑] 历史

[编辑] CPL

[编辑] C

[编辑] C++98

[编辑] C++11

[编辑] C++17

[编辑] 脚注

[编辑] 参考文献

[编辑] 缺陷报告

[编辑] 另请参阅

[编辑] 外部链接

导航

工具箱