L value (programming)
In programming, a distinction is made between L value and R value expressions within instructions . An expression within a statement has an L value if the expression references a memory location . Expressions that do not have an L-value are R-value expressions.
An L value therefore points to addressable memory. The L means that an L-value expression can be on the left side of an assignment. R-value expressions can only appear on the right side of assignments. L-value expressions are often identifiers of data types ( objects ), but they can also appear as function calls or as dereferencing fields or pointers . All L-value expressions have R-values at the same time, but not every R-value has an L-value.
Objects that appear temporarily, so-called temporaries, also count among the R values. Let us consider the following statement as an example: x = a + (b * c);
The result of b * c. If x , a , b , and c are objects of a class, it is possible that with b * ca temporary object (en: a temporary ) is created that is destroyed again when it is assigned to x . To avoid unnecessary copying of object members, C ++ offers the Move Constructor and the Move Assignment Operator .
Examples
// C++ Quellcode
#include <iostream>
typedef unsigned long long ull;
int x; // benannter Speicherort, der als L-Wert-Ausdruck verwendet werden kann
int& f(int& variable) { return variable; } // benötigt L-Wert-Argument, gibt L-Wert zurück
int g(int wert) { return wert; } // gibt einen R-Wert zurück
int main()
{
x = 3; // x ist ein L-Wert-Ausdruck, 3 ein R-Wert-Ausdruck
f(x) = 5; // f(x) ist (hier) ein L-Wert-Ausdruck, 5 ein R-Wert-Ausdruck
// g(x) = 0; // funktioniert nicht, da g(x) kein L-Wert-Ausdruck ist
// x = f(100); // funktioniert nicht, da 100 kein L-Wert-Ausdruck ist
std::cout << "Der L-Wert von x ist " << reinterpret_cast<ull>(&x) << std::endl;
std::cout << "Der L-Wert von f(x) ist " << reinterpret_cast<ull>(&f(x)) << std::endl;
std::cout << "Der R-Wert von f(x) ist " << f(x) << std::endl;
// std::cout << "Der L-Wert von g(x) ist " << reinterpret_cast<ull>(&g(x)) << std::endl; // funktioniert nicht
std::cout << "Der R-Wert von g(x) ist " << g(x) << std::endl;
// -----------------------------------------------------------------
int feld[3] = { 11, 22, 33 };
int * zeiger = feld;
feld[2] = 1; // Arrayindexierung als L-Wert-Ausdruck
*(zeiger+2) = 0; // Zeigerdereferenzierung als L-Wert-Ausdruck
std::cout << "Der L-Wert von *(zeiger+2) ist " << reinterpret_cast<ull>(zeiger+2) << std::endl;
std::cout << "Der L-Wert von feld[2] ist " << reinterpret_cast<ull>(&feld[2]) << std::endl;
//------------------------------------------------
// Hier wird ein temporaeres std::string -Objekt benutzt. 'Temporaries' besitzen R-Werte
std::cout << "Das Wort \"Container\" besteht aus " << std::string("Container").length() << " Zeichen.\n";
}
Possible output:
Der L-Wert von x ist 0x602194
Der L-Wert von f(x) ist 0x602194
Der R-Wert von f(x) ist 5
Der R-Wert von g(x) ist 5
Der L-Wert von *(zeiger+2) ist 0x7ffdf9ec0808
Der L-Wert von feld[2] ist 0x7ffdf9ec0808
Das Wort "Container" besteht aus 9 Zeichen.
The output shows that the L-values are the memory addresses of the L-value expressions.