non comprendere il comportamento operatore di spostamento nel codice C

Question

Guardate questo codice di esempio C (estratto un test come esempio):

main() { 
    unsigned long a, b; 
    int c; 
    c = 32; 
    a = 0xffffffff << 32; 
    b = 0xffffffff << c; 
    printf ("a=%x, b=%x\n", a, b); 
} 

stampe: a=0, b=ffffffff

non riesco a capire perché b non è zero, proprio come a. Ho provato questo su Microsoft C e GCC.

Aggiornamento: ho fissato l'errore di battitura stupido (che avrebbe dovuto essere < < C e non < < b ovviamente). Ma la mia domanda rimane valida, ad es. il risultato è sempre lo stesso.

Answer 1

In C è un comportamento indefinito verso sinistra spostare più della larghezza dell'operando promosso.

(C99, 6.5.7p3) "Se il valore dell'operando di destra è negativo o è maggiore o uguale alla larghezza dell'operando di sinistra promosso, il comportamento non è definito."

presumo negli esempi seguenti int e unsigned int tipi sono 32 bit

Il tipo di un intero esadecimale senza suffisso costante è il primo nell'elenco corrispondente in cui il suo valore può essere rappresentato:. int , unsigned int, long, unsigned long, long long, unsigned long long.

Così qui 0xFFFFFFFF è di tipo unsigned int e 0xFFFFFFFF << 32 è un comportamento indefinito.

Answer 2

Non si può mai inizializzato b a nulla prima di usarlo qui:

b = 0xffffffff << b; 

in modo che possa essere qualsiasi cosa. (Credo che in realtà intendeva spostare da c.)

---

A parte questo:

Il problema principale è che lo spostamento dal # di bit nel tipo di dati o più è comportamento indefinito.
Quindi, se il letterale 0xffffffff è un intero a 32 bit, quindi la linea:

a = 0xffffffff << 32; 

non è definito dalla norma. (Vedere i commenti.)

---

Si dovrebbe anche essere sempre un avviso del compilatore:

warning C4293: '<<' : shift count negative or too big, undefined behavior 

Answer 3

Hai b = 0xffffffff << b;, ma forse volevi dire b = 0xffffffff << c;

Answer 4

Perché dovrebbe essere pari a zero? Si spostarlo da un numero spazzatura (il primo valore di b) che può essere 0.

Answer 5

Lei non è stato inizializzato B, quindi sta andando ad avere qualsiasi valore (casuale) è in quel particolare locazione di memoria al momento il programma funziona.

Answer 6

Quando si raggiunge la linea b = 0xffffffff << b;, il valore di b non è stato assegnato. Sembra che il suo valore sia zero, rendendo l'istruzione b = 0xffffffff << b;. Quale espelle la risposta data.

Answer 7

Le buone pratiche sono AND dopo il turno. In questo caso sai bene cosa succede.

examply:

b << = 4; 
b &= 0xfffffff0; 

Answer 8

Scommetto che dopo aver corretto il tuo errore di battitura si ottengono 2 zeri come risultato. Ecco perché: Se il tuo programma è (scommetto) compilato come rilascio, hai attivato le ottimizzazioni. Ciò significa che il compilatore userà il cosiddetto "folding costante" e la CPU non eseguirà nemmeno questi spostamenti. Sotto il codice del cofano ci saranno 2 costanti di zero inserite nello stack e inviterà printf. I risultati di queste operazioni (turni) diventeranno essenzialmente costanti nel programma. Quindi non ci sono comportamenti indefiniti, ecc - la vostra A e B diventa valori costanti ed otterrete STH come:

push 0 
push 0 
push offset to printf format string 
call to printf 

Answer 9

Nessuno ha menzionato un altro aspetto interessante del problema. Sui computer x86, la quantità di spostamento viene usata come modulo 32, quindi uno spostamento di 32 sarà effettivamente uno spostamento di 0. Sulle macchine ARM, il valore di spostamento (se proveniente da un registro) non viene alterato, quindi qualsiasi valore di spostamento di 32 o maggiore risulterà sempre 0 nel registro di destinazione.

In particolare nel tuo problema, il compilatore è intelligente riguardo ai valori costanti, quindi trasforma (0xffffffff < < 32) nel valore corretto (0). Nel tuo secondo esempio, il compilatore non può calcolare direttamente l'importo dello spostamento poiché proviene da una variabile. Se eseguito su una macchina Intel, lo spostamento verso sinistra di 32 risulta in uno spostamento a sinistra di 0.