What exactly is an R-Value in C++?

Rvalue & Lvalue

Before Explaining This two notation let's Check what is Called Movable and Identity

Identity:- In short anything that has name & we can point to or Reference to know that whether it is same value or Different Value

Moving:- In short anything whose content can be moved from one place or Memory to Other

Lvalue are those value that has Identity so we can point to it or Reference it, but cannot Move it These are called Classical Values

Rvalue are one that are movable (whether has identity or not) these contains temporary values or ADT that support move

"Could someone explain, or point me to some sort of explanation, of what R-Value is? I'm not really sure what it is"

The term lvalue originally referred to an expression that could be the left hand side of an assignment. Correspondingly, an rvalue (although as I recall that term was not used by the C89 standard), was originally just the opposite: an expression that could not be the left hand side of an assignment, but that could only be the right hand side.

C++11 complicated this by adding several more nuanced terms, but let's concentrate on the C++03 meanings.

For example, if you have

int x;

then the assignment x = 42 is OK, so x is an lvalue expression.

As a counter-example, the assigment x+0 = 42 is not OK, so x+0 is an rvalue expression.

And so is the expression 2+2, it's an rvalue expression.

So, if the requirement is that your program should include an rvalue, then just write 2+2 or e.g. (more advanced) 6*7, in main.

Original C didn't have const. In C++, with const, you have to disregard the const for the purpose of designating an expression as lvalue or rvalue. The critical point is then whether the expression guaranteed refers to an object in memory, an object with an address: if so, then the expression is an lvalue.

A reference type implies lvalue, because an expression of reference type is necessarily referring to an object with a memory address, i.e. that expression is an lvalue.

However, other than references there's no connection between type and lvalue/rvalue. For example, both x and x+0 are expressions of type int, and they yield the same int value. But the former is an lvalue expression, while the latter is an rvalue expression.

As a general rule, if you can apply the built-in address operator, then it's an lvalue expression, and otherwise it's an rvalue expression.

The term rvalue derives from its historical context --- it was something that could only go on the Right-hand side of an assignment, as opposed to an lvalue which could go on the left-hand side of an assignment. Thus a named variable (e.g. x) is an lvalue, but a literal integer (e.g. 42) is an rvalue.

However, in modern C++ it is more nuanced than that.

In C++, an rvalue is an unnamed object or a member of such an object which is not a reference.

Some examples:

std::string s;

std::string foo(){ return "foo";}

struct X {
    std::string s;
};

std::string& bar() {return s;}

void baz(std::string const& x){}

s=std::string("hello"); // 1
s=foo();                // 2
std::string s2=bar();   // 3
baz("hello");           // 4
s=X().s;                // 5

In (1), the temporary std::string object created from the string literal is an rvalue.

In (2), the object returned from foo() is an rvalue.

In (3), bar() returns a reference so there are no rvalues.

In (4), the temporary std::string object implicitly created from the string literal is an rvalue.

In (5), the temporary X object is an rvalue, so therefore so is the s member.

Expressions such as x+3 typically result in a temporary, which is thus an rvalue. However, if operator overloading has been used to change the return type to a reference, then the result is an lvalue.