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.

## Lvalue och Rvalue

I C++ är **lvalues** och **rvalues** två grundläggande kategorier av uttryck:

- **Lvalue**: ett objekt eller en minnesplats som har ett namn och kan stå på vänster sida av en tilldelning;
- **Rvalue**: ett temporärt värde eller en literal som inte har en bestående minnesadress och vanligtvis står på höger sida av en tilldelning.

**Exempel:**
```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-referenser

En **lvalue-referens** gör det möjligt att skapa ett alias för en befintlig variabel (en lvalue). Den deklareras med ett 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-referenser **kan inte** bindas till rvalues (temporära värden eller literaler).

## Rvalue-referenser

En **rvalue-referens** gör det möjligt att binda en referens till ett temporärt värde (en rvalue). Den deklareras med `&&`:

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

- Rvalue-referenser **kan inte** bindas till lvalues (namngivna variabler).
- De är användbara för att optimera kod, till exempel genom att flytta resurser istället för att kopiera dem.

## Regler för referensbindning

- Lvalue-referenser (`&`) binds till lvalues.
- Rvalue-referenser (`&&`) binds till rvalues.

**Exempel:**
```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
```

Att förstå dessa koncept hjälper dig att skriva säkrare och mer effektiv C++-kod, särskilt när du arbetar med moderna funktioner som move-semantik.

Lås upp kraften i minneshantering. Fördjupa dig i grunderna i programmering med denna omfattande kurs som är utformad för nybörjare och personer som vill stärka sina kunskaper om pekare och referenser i C++. Att behärska dessa grundläggande koncept är avgörande för att frigöra hela potentialen i dina programmeringskunskaper.

Lär dig grunderna i pekare på ett enkelt och icke överväldigande sätt! Utforska hur pekare fungerar, deras syntax och praktiska tillämpningar genom tydliga exempel och lättförståeliga förklaringar.

Rvalue- och Lvalue-referenser

Lvalue och Rvalue

Lvalue-referenser

Rvalue-referenser

Regler för referensbindning