rvalue Nedir

rvalue Değişkenin Adresi

Normalde rvalue değişkenin adresiyle ilgilenmemek gerekir.

Örnek

Aynı adres tekrar tekrar rvalue değişken için kullanılabilir.

Örnek

Elimizde şöyle bir kod olsun

const int *funct(const int &x) { return &x; }

Şöyle yaparız

// same address
std::cout << funct(3) << std::endl; //#1
std::cout << funct(4) << std::endl; //#2

Ancak aynı ifade içinde derleyici mevcuren farklı adresler kullanacaktır. Şöyle yaparız

// different addresses
std::cout << funct(3) << std::endl << funct(4) << std::endl; //#3

Açıklaması şöyle

Two alive objects in C++ (almost) always have different addresses.

Since temporaries in #1 #2 have non-overlapping lifetimes, the compiler is free to reuse the storage of #1 for #2 .

But in #3 all temporaries are alive until the end of the expression (for obvious reasons) and in this case they have to have different addresses.

rvalue ve & operator

Açıklaması şöyle. Adresle ilgilenmememiz için bize zorluk bile çıkarılmış :)

Now, there's an expression category rule that you can't apply & to an expression of the rvalue category. The purpose of this rule and these categories is to avoid errors where a temporary object is used after it is destroyed. 

Örnek
Şu kod derlenmez.

int *p = &5;    // not allowed due to category rules
*p = 6;         // oops, dangling pointer

Ancak rvalue değişkenin adresini almak mümkün. Şöyle yaparız.

template<typename T> auto f(T&&t) -> T& { return t; }
// ...
int *p = f(5); // Allowed
*p = 6;        // Oops, dangling pointer, no compiler error message.

rvalue Değişken lvalue Haline Gelebilir
Örnek
Şöyle yaparız.

int arr[] = {1, 2};
int* p = &arr[0];
*(p + 1) = 10;   // OK: p + 1 is an rvalue, but *(p + 1) is an lvalue