# Expressions: value categories and reference types

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:

```cpp
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:

```cpp
type &&ref = rvalue_expr;
```

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

A forwarding reference is now available:

```cpp
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](https://pvs-studio.com/en/blog/terms/6515/) 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:

```cpp
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](https://pvs-studio.com/en/blog/terms/6515/) is the implementation of perfect forwarding in the standard library\.