warning: overflow in expression; result is -1'141'367'296 with type 'int'
Un calcul cu constante întregi depășește limita lui int (aproximativ 2,1 miliarde), iar compilatorul îți arată valoarea greșită rezultată. Chiar dacă rezultatul ajunge într-un long long, calculul se face în int. Fă primul operand long long: 365LL * 24 * 3600 * 100.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Într-o expresie ca 365 * 24 * 3600 * 100, toți operanzii sunt int, deci și înmulțirile se fac în int. Rezultatul real (3153600000) depășește maximul lui int (2147483647). La întregi cu semn, depășirea e comportament nedefinit; în practică rezultatul „se întoarce” și devine negativ.
Când calculul e făcut din constante, clang îl evaluează la compilare și avertizează (-Winteger-overflow, activ implicit), arătând rezultatul greșit: result is -1'141'367'296 with type 'int'. Clang 21 pune separatoare de mii ('); versiunile mai vechi afișează -1141367296.
Faptul că variabila destinație este long long nu ajută: tipul calculului e decis de operanzi, nu de variabila în care pui rezultatul. Trebuie ca măcar primul operand să fie long long (365LL), ca toate înmulțirile să se facă pe 64 de biți.
De ce apare: cauzele frecvente
1Calcul în int pus într-un long long
long long secunde = 365 * 24 * 3600 * 100;long long secunde = 365LL * 24 * 3600 * 100;Sufixul LL face din primul operand un long long, iar celelalte se convertesc la același tip.
2Constante mari înmulțite
const int MILION = 1000000;
long long total = MILION * MILION;const long long MILION = 1000000;
long long total = MILION * MILION;Cu constanta de tip long long, produsul (10^12) încape.
3Variabile, nu constante
int a = 50000, b = 50000;
long long p = a * b; // fara avertismentint a = 50000, b = 50000;
long long p = (long long)a * b;Cu variabile compilatorul nu poate avertiza, dar depășirea e aceeași; convertește un operand înainte de înmulțire.
Repară eroarea, direct în pagină
Prima linie (#pragma) transformă avertismentul în eroare. Programul calculează câte secunde au 100 de ani, dar compilarea dă overflow in expression; result is -1'141'367'296 with type 'int'. Fă calculul pe 64 de biți, ca programul să afișeze Secunde in 100 de ani: 3153600000.
#pragma clang diagnostic error "-Winteger-overflow"
#include <iostream>
using namespace std;
int main() {
long long secunde = 365 * 24 * 3600 * 100;
cout << "Secunde in 100 de ani: " << secunde << "\n";
return 0;
}Secunde in 100 de ani: 3153600000
Indiciu
Scrie primul operand ca 365LL.
Reparația
#pragma clang diagnostic error "-Winteger-overflow"
#include <iostream>
using namespace std;
int main() {
long long secunde = 365LL * 24 * 3600 * 100;
cout << "Secunde in 100 de ani: " << secunde << "\n";
return 0;
}De ce merge
Toți operanzii erau int, deci și înmulțirile se făceau în int. Rezultatul real, 3153600000, depășește 2147483647, iar compilatorul a calculat valoarea greșită, -1141367296.
Cu 365LL, primul operand e long long. Fiecare înmulțire următoare se face pe 64 de biți, iar rezultatul corect încape fără probleme în secunde.
Alte forme ale mesajului
warning: overflow in expression; result is -1141367296 with type 'int' [-Winteger-overflow]warning: overflow in expression; result is -2'147'483'648 with type 'int' [-Winteger-overflow]warning: integer overflow in expression of type 'int' results in '-1141367296' [-Woverflow]error: constexpr variable 'x' must be initialized by a constant expression note: value 3153600000 is outside the range of representable values of type 'int'
Cum o eviți pe viitor
- Când un calcul poate trece de 2 miliarde, fă primul operand
long long(1LL * a * bsau sufixulLL). - Declară constantele mari direct ca
long longsauconstexpr long long. - Pentru verificări în teste, compilează cu
-fsanitize=undefined: depășirile de la rulare sunt raportate. - Reține limitele:
int≈ 2,1 × 10^9,long long≈ 9,2 × 10^18.
Întrebări frecvente
De ce rezultatul e negativ?
Pentru că, în practică, procesorul păstrează doar ultimii 32 de biți ai rezultatului, iar bitul de semn al lui int ajunge 1. Standardul spune însă că depășirea la întregi cu semn e nedefinită, deci compilatorul poate face și altceva.
La unsigned există aceeași problemă?
La unsigned, depășirea e definită: rezultatul se calculează modulo 2^32 (sau 2^64). Nu e comportament nedefinit, dar valoarea e tot greșită dacă nu asta voiai.
Erori înrudite
warning: implicit conversion loses integer precision: 'long long' to 'int' Pui o valoare dintr-un tip întreg mai mare (long long, size_t pe 64 de biți) într-un int, care are doar 32 de biți. Dacă valoarea nu încape, se pierd cifre. Folosește același tip mare pentru variabila destinație sau convertește explicit, după o verificare. error: integer literal is too large to be represented in any integer type Ai scris în cod un număr întreg mai mare decât încape în cel mai mare tip întreg (unsigned long long, aproximativ 1,8 × 10^19). Coduri lungi (IBAN, card, ID-uri de 20 de cifre) se păstrează ca string, iar valorile uriașe ca double. warning: implicit conversion from 'double' to 'int' changes value from 3.7 to 3 Ai pus un număr cu zecimale într-o variabilă int, iar zecimalele se pierd (3.7 devine 3, fără rotunjire). Folosește double pentru valori cu zecimale sau rotunjește explicit cu round(). warning: division by zero is undefined Compilatorul vede o împărțire (sau un rest %) la zero direct în cod. La întregi, împărțirea la zero e comportament nedefinit și de obicei oprește programul. Împarte la valoarea corectă și verifică împărțitorul când vine din date. Învață C++ de la zero, cu exerciții la fiecare lecție
Curs C++: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
