Thread 1: Swift runtime failure: arithmetic overflow
La rulare, un calcul cu întregi a ieșit din limitele tipului (sub 0 la UInt, peste Int.max, peste 127 la Int8), iar Swift a oprit programul. Verifică valorile înainte de operație sau folosește un tip mai mare.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
În Swift, depășirea limitelor la +, -, * nu dă un rezultat „dat peste cap” ca în C: programul se oprește imediat. În Xcode, linia problematică e marcată cu Thread 1: Swift runtime failure: arithmetic overflow; în terminal programul se termină cu Illegal instruction sau Trace/breakpoint trap, iar în editorul nostru vezi că programul s-a oprit brusc.
Cazurile tipice:
- scăderi pe
UIntcare ar da sub zero (stoc 5, comandat 8); - sume sau produse mari pe
Int, mai ales undeIntare 32 de biți (editorul din browser, unele platforme); - tipuri mici (
Int8,UInt8) folosite pentru contoare.
Dacă valorile sunt constante, eroarea apare deja la compilare (arithmetic operation ... results in an overflow). La rulare, folosește verificări înainte de calcul, Int64, sau addingReportingOverflow ca să afli dacă a depășit.
De ce apare: cauzele frecvente
1Scădere sub zero pe UInt
func ramas(stoc: UInt, comandat: UInt) -> UInt {
return stoc - comandat
}
print(ramas(stoc: 5, comandat: 8))func ramas(stoc: UInt, comandat: UInt) -> UInt {
return comandat > stoc ? 0 : stoc - comandat
}
print(ramas(stoc: 5, comandat: 8))UInt nu are valori negative; verificarea dinainte evită ieșirea din interval.
2Sumă prea mare pentru Int pe 32 de biți
let vanzari = [900_000_000, 800_000_000, 700_000_000]
var total = 0
for v in vanzari { total += v }let vanzari = [900_000_000, 800_000_000, 700_000_000]
var total: Int64 = 0
for v in vanzari { total += Int64(v) }
print(total)2400000000 depășește 2147483647, limita lui Int pe 32 de biți. Int64 are loc.
3Contor pe un tip mic
var nivel: Int8 = 120
for _ in 0..<10 { nivel += 1 }var nivel = 120
for _ in 0..<10 { nivel += 1 }
print(nivel)Int8 se oprește la 127. Folosește Int dacă nu ai un motiv clar pentru un tip mic.
Repară eroarea, direct în pagină
Funcția ramas calculează câte bucăți rămân în stoc după o comandă. Pentru (15, 5) și (5, 8), programul trebuie să afișeze Ramas: 10 și Ramas: 0, dar la al doilea apel se oprește brusc (Swift runtime failure: arithmetic overflow). Întoarce 0 când se comandă mai mult decât e în stoc.
func ramas(stoc: UInt, comandat: UInt) -> UInt {
return stoc - comandat
}
print("Ramas: \(ramas(stoc: 15, comandat: 5))")
print("Ramas: \(ramas(stoc: 5, comandat: 8))")Ramas: 10 Ramas: 0
Indiciu
Compară comandat cu stoc înainte de scădere.
Reparația
func ramas(stoc: UInt, comandat: UInt) -> UInt {
if comandat > stoc {
return 0
}
return stoc - comandat
}
print("Ramas: \(ramas(stoc: 15, comandat: 5))")
print("Ramas: \(ramas(stoc: 5, comandat: 8))")De ce merge
UInt poate ține doar valori de la 0 în sus, deci 5 - 8 nu are rezultat valid. Swift nu trunchiază: oprește programul la rulare. Verificarea comandat > stoc tratează cazul înainte de scădere și întoarce 0, iar scăderea rămâne doar pentru situațiile în care rezultatul e pozitiv sau zero, ca la 15 - 5 = 10.
Alte forme ale mesajului
Swift runtime failure: arithmetic overflowIllegal instruction (core dumped)Trace/breakpoint trap
Cum o eviți pe viitor
- Folosește
Intpentru aproape toate numerele;UIntdoar când chiar ai nevoie de biți, nu ca să „interzici” negativele. - Pentru sume de bani sau timpi în milisecunde, folosește
Int64explicit. - Înainte de o scădere care poate da negativ, compară valorile.
- Pentru calcule riscante,
let (r, depasit) = a.addingReportingOverflow(b)îți spune dacă a depășit.
Întrebări frecvente
De ce Swift oprește programul în loc să continue?
Pentru că un rezultat depășit e aproape mereu un bug (un sold uriaș în loc de unul negativ, de exemplu). E mai sigur să te oprească decât să lucrezi mai departe cu un număr greșit.
Cum fac totuși calcule care se dau peste cap intenționat?
Cu operatorii &+, &-, &*. Ei ignoră depășirea, ca în C, și se folosesc de exemplu la funcții de hash.
Erori înrudite
error: arithmetic operation '86400000 * 30' (on type 'Int') results in an overflow Compilatorul a calculat dinainte o expresie cu valori constante și rezultatul nu încape în tipul ei (Int, Int8, Int32...). Folosește un tip mai mare, de exemplu Int64, sau reorganizează calculul. Fatal error: Not enough bits to represent the passed value Convertești un număr într-un tip întreg prea mic pentru el, de exemplu Int8(300) sau UInt8(256), iar programul se oprește. Folosește un tip mai mare (Int), verifică intervalul înainte sau alege explicit Int8(clamping:) ori Int8(exactly:). Fatal error: Double value cannot be converted to Int because it is either infinite or NaN Convertești la Int un Double care e infinit sau NaN, de obicei rezultatul unei împărțiri la zero (media unei liste goale). Verifică întâi împărțitorul (sau x.isFinite) și tratează separat cazul gol. Învață Swift de la zero, cu exerciții la fiecare lecție
Curs Swift (iOS): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
