# Limitele tipurilor și depășirea (overflow)

> Pagina: https://bacalaurescu.ro/informatica/lectii/tipuri-de-date-si-variabile/limitele-tipurilor-si-overflow
> Markdown: https://bacalaurescu.ro/informatica/lectii/tipuri-de-date-si-variabile/limitele-tipurilor-si-overflow.md
> Sursa: Bacalaurescu (bacalaurescu.ro), conținut gratuit pentru BAC 2027.

Materia: [Informatică](https://bacalaurescu.ro/informatica)

Capitolul: [Tipuri de date și variabile](https://bacalaurescu.ro/informatica/lectii/tipuri-de-date-si-variabile)
Actualizat: 2026-11-01

Cât încape în int și long long, ce se întâmplă la depășire și cum o eviți.

## Pe scurt pentru BAC

- `int` ocupă 4 octeți și ține valori între aproximativ $-2 \cdot 10^9$ și $2 \cdot 10^9$, iar `long long` ocupă 8 octeți.
- Depășirea lui `int` nu dă eroare la rulare: valoarea se înfășoară, iar rezultatul devine absurd.
- Sufixul `1LL` din `1LL * a * b` forțează calculul pe 64 de biți încă de la primul pas.
- Realele se reprezintă aproximativ, așa că `0.1 + 0.2 == 0.3` e fals, iar comparațiile se fac cu toleranță, ca `fabs(x - y) < 1e-9`.

## Limitele care trebuie știute

| Tip | Dimensiune | Interval aproximativ |
|---|---|---|
| `int` | 4 octeți | $-2 \cdot 10^9 \ldots 2 \cdot 10^9$ (exact $\pm 2147483647$) |
| `long long` | 8 octeți | $\pm 9{,}2 \cdot 10^{18}$ |
| `char` | 1 octet | un caracter (codul 0-255 / -128..127) |
| `double` | 8 octeți | reale, ~15 cifre semnificative |

Regula practică: peste ~2 miliarde → `long long`; numărul de cifre al lui n! sau produse mari → tot `long long` sau regândirea algoritmului.

## Overflow: ce se întâmplă la depășire

Depășirea lui `int` NU dă eroare la rulare: valoarea "se înfășoară" (comportament de aritmetic modular), rezultatul devine absurd, adesea NEGATIV.

**Exemplu clasic.** `int a = 2000000000; a + a` nu dă 4 miliarde, ci un număr negativ: 4·10⁹ nu încape în int.

## Capcana subtilă: produsul a doi int

```cpp
int a = 100000, b = 100000;
long long p = a * b;
```

GREȘIT: `a * b` se calculează ÎN int (overflow), abia apoi se copiază în long long. Corect:

```cpp
long long p = 1LL * a * b;
```

Sufixul `1LL` forțează calculul pe 64 de biți de la primul pas.

## double: capcana comparării

Realele se reprezintă aproximativ: `0.1 + 0.2 == 0.3` e FALS în C++. Comparațiile de reale se fac cu toleranță: `fabs(x - y) < 1e-9`.

> [!RETINE]
> int ≈ ±2·10⁹, long long ≈ ±9·10¹⁸. La produse: 1LL * a * b. Depășirea nu anunță: rezultate negative "din senin" = simptomul clasic.

## Greșeli frecvente

1. Suma a n numere de până la 10⁹: pentru n ≥ 3 rezultatul cere long long.
2. `long long p = a * b` cu a, b int NU te salvează: conversia vine prea târziu.
3. La double, egalitatea strictă e nesigură: folosește toleranță.