Our website uses cookies to enhance your browsing experience.
Accept
to the top
close form

Fill out the form in 2 simple steps below:

Your contact information:

Step 1
Congratulations! This is your promo code!

Desired license type:

Step 2
Team license
Enterprise license
** By clicking this button you agree to our Privacy Policy statement
close form
Request our prices
New License
License Renewal
--Select currency--
USD
EUR
* By clicking this button you agree to our Privacy Policy statement

close form
Free PVS‑Studio license for Microsoft MVP specialists
* By clicking this button you agree to our Privacy Policy statement

close form
To get the licence for your open-source project, please fill out this form
* By clicking this button you agree to our Privacy Policy statement

close form
I am interested to try it on the platforms:
* By clicking this button you agree to our Privacy Policy statement

close form
check circle
Message submitted.

Your message has been sent. We will email you at


If you haven't received our response, please do the following:
check your Spam/Junk folder and click the "Not Spam" button for our message.
This way, you won't miss messages from our team in the future.

>
>
>
Expressions: value categories and refer…

Expressions: value categories and reference types

Sep 17 2021

Each expression in C++ has two properties – a type and a value category. Depending on the value category, a reference of a certain kind may be bound to an expression.

Value categories

Before move semantics, there were two categories of expressions in C++ – lvalue and rvalue. To differentiate between lvalue and rvalue, the following rule was used: if an expression could appear on the left-hand side of an assignment expression, then it is lvalue. Otherwise, it is rvalue.

The C++11 standard introduced new value categories to support move semantics – glvalue, prvalue, and xvalue. Now any expression can belong to one of these categories.

An rvalue is a union of prvalue and xvalue. An glvalue is a union of lvalue and xvalue.

The C++ standard does not give an official definition of categories. The paper specifies which value category each expression type has.

To differentiate between lvalue, xvalue and prvalue, you can use the following rule:

  • An expression is a prvalue if it is a temporary unnamed object. For example, i++.
  • An expression is an xvalue if it is a named object whose resources can be reused. An expression is also an xvalue if it is the result of the static_cast<type &&> expression or the result of calling a function that returns type &&. For example, std::move (obj).
  • All other expressions are lvalue. For example, *ptr.

Reference kinds

Before C++11, there was only one reference kind. If you wanted to take a reference to the var variable of the type type, you had to write the following:

type &ref = var;

Such a reference is called an lvalue reference. It can be bound only to an lvalue expression.

To support move semantics, new reference types became available – an rvalue reference and a forwarding reference. If an rvalue reference is required, you must write the following:

type &&ref = rvalue_expr;

Such reference, unlike an lvalue reference, must refer to an rvalue expression.

A forwarding reference is now available:

template <typename T>
void foo(T &&arg);

where T is the template parameter derived from the function template argument. Such declaration looks like an rvalue reference declaration, but it functions differently. Due to reference collapsing, a forwarding reference can be bound to lvalue and rvalue objects. Here is the detailed description of this mechanism.

Do not confuse forwarding and rvalue references. In the example below, the T template parameter corresponds to the Base class, not to the foo function. Therefore, the arg argument of the foo function is an rvalue reference, not a forwarding one:

template <typename T>
class Base
{
  void foo(T&& arg);
};

A forwarding reference allows implementing perfect forwarding. This mechanism is responsible for moving an object of a certain type as expected: an rvalue object is moved, an lvalue object is copied. The std::forward function is the implementation of perfect forwarding in the standard library.

Popular related articles


Comments (0)

Next comments next comments
close comment form