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 grunnleggende kategorier av uttrykk:

- **Lvalue**: et objekt eller en minneplassering som har et navn og kan stå på venstre side av en tildeling;
- **Rvalue**: en midlertidig verdi eller en literal som ikke har en vedvarende minneadresse og vanligvis står på høyre side av 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-referanser

En **lvalue-referanse** lar deg lage et alias for en eksisterende variabel (en lvalue). Du erklærer den med en 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-referanser **kan ikke** binde seg til rvalues (midlertidige verdier eller litteraler).

## Rvalue-referanser

En **rvalue-referanse** lar deg binde en referanse til en midlertidig verdi (en rvalue). Du erklærer den med `&&`:

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

- Rvalue-referanser **kan ikke** binde seg til lvalues (navngitte variabler).
- De er nyttige for å optimalisere kode, for eksempel ved å flytte ressurser i stedet for å kopiere dem.

## Regler for referansebinding

- Lvalue-referanser (`&`) binder seg til lvalues.
- Rvalue-referanser (`&&`) binder seg 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å disse konseptene hjelper deg å skrive sikrere og mer effektiv C++-kode, spesielt når du arbeider med moderne funksjoner som move-semantikk.

Lås opp kraften i minnehåndtering. Fordyp deg i grunnleggende programmering med dette omfattende kurset, utviklet for nybegynnere og for dem som ønsker å styrke kunnskapen om pekere og referanser i C++. Å mestre disse essensielle konseptene er avgjørende for å frigjøre det fulle potensialet i dine programmeringsferdigheter.

Lær det grunnleggende om pekere på en enkel og oversiktlig måte. Utforsk hvordan pekere fungerer, deres syntaks og praktiske anvendelser gjennom tydelige eksempler og lettfattelige forklaringer.

Rvalue- og Lvalue-referanser

Lvalues og Rvalues

Lvalue-referanser

Rvalue-referanser

Regler for referansebinding