warning: shift count >= width of type
Muți biții cu cel puțin atâtea poziții câți biți are tipul (de ex. 1 << 32 pe un int de 32 de biți). Rezultatul e nedefinit. Folosește un tip mai lat pentru operand (1ULL << 32, uint64_t) sau o deplasare mai mică.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
La a << n și a >> n, numărul de poziții n trebuie să fie între 0 și numărul de biți ai tipului lui a minus 1. Constanta 1 are tipul int (32 de biți), deci 1 << 32 sau 1u << 40 depășesc lățimea. Standardul spune că rezultatul e nedefinit: pe x86 poate ieși 1 (procesorul ia doar ultimii 5 biți din n), pe alte platforme 0, iar optimizatorul poate face orice.
Clang avertizează când vede o constantă prea mare: shift count >= width of type (cu -Wshift-count-overflow), iar pentru valori negative shift count is negative. Dacă n e o variabilă, nu primești avertisment, dar problema e aceeași.
Cazul tipic: lucrezi cu flag-uri sau cu măști pe 64 de biți și scrii 1 << bit în loc de 1ULL << bit. Tipul operandului din stânga decide lățimea, nu tipul variabilei în care pui rezultatul.
De ce apare: cauzele frecvente
1Constanta 1 e int
unsigned long long masca = 1 << 40;unsigned long long masca = 1ULL << 40;1ULL are 64 de biți, deci deplasarea cu 40 de poziții e validă.
2Flag-uri pe 64 de biți
uint64_t flaguri = 0;
flaguri |= 1u << 35;uint64_t flaguri = 0;
flaguri |= UINT64_C(1) << 35;UINT64_C(1) din stdint.h creează constanta 1 cu tipul pe 64 de biți.
3Deplasare cu o valoare negativă
int x = 8 >> -1;int x = 8 << 1;O deplasare negativă e tot nedefinită. Alege direcția prin operator, nu prin semn.
Repară eroarea, direct în pagină
Programul setează bitul 32 într-un set de flag-uri pe 64 de biți, dar folosește constanta 1u, care are doar 32 de biți, așa că apare shift count >= width of type. Repară constanta ca programul să afișeze Flaguri: 4294967296.
#pragma clang diagnostic error "-Wshift-count-overflow"
#include <stdio.h>
int main(void) {
unsigned long long flaguri = 0;
flaguri |= 1u << 32;
printf("Flaguri: %llu\n", flaguri);
return 0;
}Flaguri: 4294967296
Indiciu
Constanta din stânga lui << trebuie să aibă 64 de biți: 1ULL.
Reparația
#pragma clang diagnostic error "-Wshift-count-overflow"
#include <stdio.h>
int main(void) {
unsigned long long flaguri = 0;
flaguri |= 1ULL << 32;
printf("Flaguri: %llu\n", flaguri);
return 0;
}De ce merge
1u are tipul unsigned int, cu 32 de biți, deci deplasarea cu 32 de poziții depășește lățimea tipului și are rezultat nedefinit. 1ULL are 64 de biți, deci 1ULL << 32 este exact 2^32 = 4294967296, iar %llu îl afișează corect.
Alte forme ale mesajului
warning: shift count >= width of type [-Wshift-count-overflow]warning: shift count is negative [-Wshift-count-negative]warning: left shift count >= width of type [-Wshift-count-overflow]warning: right shift count >= width of type [-Wshift-count-overflow]
Cum o eviți pe viitor
- Pentru măști peste 31 de biți scrie operandul cu sufix (
1ULL) sau cuUINT64_C(1). - Folosește tipuri cu lățime fixă din
stdint.h(uint32_t,uint64_t) pentru operații pe biți. - Când numărul de poziții vine dintr-o variabilă, verifică că e între 0 și lățimea tipului minus 1.
- Rulează testele cu
-fsanitize=undefined, care prinde deplasările invalide la rulare.
Întrebări frecvente
De ce primesc 1 în loc de 0 pe calculatorul meu?
Pe x86, instrucțiunea de deplasare folosește doar ultimii 5 biți din numărul de poziții, deci 1 << 32 devine 1 << 0. Standardul C nu garantează nimic, deci rezultatul diferă între procesoare și compilatoare.
Variabila rezultat e pe 64 de biți, de ce nu ajunge?
Expresia 1 << 40 se calculează în tipul operandului din stânga, int, înainte de a fi pusă în variabilă. Tipul variabilei nu schimbă calculul.
Erori înrudite
warning: overflow in expression; result is -1'702'967'296 with type 'int' Un calcul cu constante întregi depășește valoarea maximă a unui int (2.147.483.647), chiar dacă rezultatul ajunge într-un long long. Calculul se face în int înainte de atribuire. Fă unul dintre operanzi long long: 30LL * 24 * ... warning: & has lower precedence than ==; == will be evaluated first În flag & MASCA == 0, comparația == se face înainte de &, deci calculezi flag & (MASCA == 0). Pune paranteze în jurul operației pe biți: (flag & MASCA) == 0. warning: implicit conversion loses integer precision: 'long long' to 'int' Pui o valoare dintr-un tip întreg mare (long long, size_t, long) într-unul mai mic (int, char), iar biții în plus se pierd dacă valoarea nu încape. Păstrează rezultatul într-o variabilă de același tip (long long, size_t) sau convertește explicit doar după ce ai verificat că valoarea încape. Învață Limbajul 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.
