Summary  
This chapter explains how lvalue (`&`) and rvalue (`&&`) references in C++ bind to named variables versus temporaries, and how these binding rules underpin safer and more efficient code via move semantics.  

General domain of usage  
Performance optimization through move semantics in C++ code.

## Lvalues og Rvalues

I C++ er **lvalues** og **rvalues** to grundlæggende kategorier af udtryk:

- **Lvalue**: et objekt eller en hukommelsesplacering, der har et navn og kan stå på venstre side af en tildeling;
- **Rvalue**: en midlertidig værdi eller literal, der ikke har en vedvarende hukommelsesadresse og normalt optræder på højre side af en tildeling.

**Eksempler:**
```cpp
int x = 10;      // x is an lvalue, 10 is an rvalue
x = 20;         // x (lvalue) can be assigned a new value (rvalue 20)
```

## Lvalue-referencer

En **lvalue-reference** gør det muligt at oprette et alias for en eksisterende variabel (en lvalue). Den deklareres med et enkelt `&`:

```cpp
int a = 5;
int& ref = a;   // ref is an lvalue reference to a
ref = 8;        // changes the value of a to 8
```

- Lvalue-referencer **kan ikke** binde til rvalues (midlertidige værdier eller litteraler).

## Rvalue-referencer

En **rvalue-reference** gør det muligt at binde en reference til en midlertidig værdi (en rvalue). Den deklareres med `&&`:

```cpp
int&& temp = 42; // temp is an rvalue reference bound to the temporary value 42
```

- Rvalue-referencer **kan ikke** binde til lvalues (navngivne variabler).
- Anvendes til at optimere kode, f.eks. ved at flytte ressourcer i stedet for at kopiere dem.

## Regler for referencebinding

- Lvalue-referencer (`&`) binder til lvalues.
- Rvalue-referencer (`&&`) binder til rvalues.

**Eksempel:**
```cpp
int x = 7;
int& lref = x;      // valid: lref binds to lvalue x
// int& lref2 = 8;  // error: cannot bind lvalue reference to rvalue

int&& rref = 8;     // valid: rref binds to rvalue 8
// int&& rref2 = x; // error: cannot bind rvalue reference to lvalue
```

Forståelse af disse begreber hjælper med at skrive mere sikre og effektive C++-programmer, især når der arbejdes med moderne funktioner som move-semantik.

Lås op for kraften ved hukommelsesmanipulation. Dyk ned i grundlæggende programmering med dette omfattende kursus, designet til begyndere og personer, der ønsker at styrke deres viden om pointers og referencer i C++. Beherskelse af disse essentielle begreber er afgørende for at udnytte det fulde potentiale af dine programmeringsevner.

Lær det grundlæggende om pointers på en enkel og overskuelig måde. Udforsk hvordan pointers fungerer, deres syntaks og praktiske anvendelser gennem klare eksempler og letforståelige forklaringer.

Rvalue- og Lvalue-referencer

Lvalues og Rvalues

Lvalue-referencer

Rvalue-referencer

Regler for referencebinding