Se char c = 0x80, perché printf ("% d \ n", c << 1) restituisce -256?

Question

#include<stdio.h> 
int main(void) 
{ 
    char c = 0x80; 
    printf("%d\n", c << 1); 
    return 0; 
} 

In questo caso, l'uscita è -256. Se scrivo c << 0, l'output è -128.

Non capisco la logica dietro questo codice.

Answer 1

già il punto di partenza è problematica:

char c = 0x80; 

Se (come apparentemente nel tuo caso) char è un tipo firmato, si sta assegnando il numero intero costante 128 a un tipo che è garantito solo per contenere i valori up a 127. Il tuo compilatore può quindi scegliere di darti qualche valore definito di implementazione (-128 nel tuo caso, suppongo) o di emettere un errore di intervallo.

Quindi si sta eseguendo uno spostamento a sinistra su quel valore negativo. Questo dà un comportamento indefinito. In totale si hanno diverse scelte implementative definito più un comportamento indefinito che determinano il risultato:

• signedness di char
• la scelta di come convertire 128 a signed char
• la larghezza della char
• la rappresentazione segno di int (ci sono tre possibilità)
• la scelta su come implementare (o meno) lo spostamento a sinistra su negativo int

Potrebbe essere un buon esercizio per cercare tutti questi casi e per vedere quali potrebbero essere i diversi risultati.

In sintesi alcune raccomandazioni:

• scegliere un costante appropriata per inizializzare una variabile aritmetica
• non fare con la pianura char
• non facciamo spostamento a sinistra sui tipi firmati

Answer 2

char può essere firmato sulla piattaforma, nel qual caso 0x80 rappresenta -128 (presupponendo il complemento a due).

Quando un char viene utilizzato come operando con l'operatore <<, viene promosso a int (fermo -128). Quindi, quando applichi lo spostamento a sinistra, ottieni -256. Tecnicamente, il passaggio dei valori negativi è definito dall'implementazione indefinito, ma ciò che viene visualizzato è un comportamento tipico.

Answer 3

c assegnato 0x80. Supponendo byte da 8 bit, il suo valore in rappresentazione binaria è 10000000. Apparentemente, sulla tua piattaforma, char è un tipo firmato. Quindi, 0x80 (ad esempio 10000000) corrisponde a -128.

Quando << viene applicato a un valore char, viene promosso a int e il segno viene mantenuto. Quindi, quando spostato una volta a sinistra, con numeri interi a 32 bit, diventa 11111111111111111111111100000000 (complemento a due) che è -256.

Answer 4

Mi chiedo perché il compilatore non si lamenta di un avviso che 0x80 non si adatta al char, che sulla piattaforma può rappresentare solo valori da -0x80 a 0x7F.

Prova questo pezzo di codice:

#include <stdio.h> 
#include <limits.h> 
#include <stdlib.h> 

int main() { 
     printf("char can represent values from %d to %d.\n", CHAR_MIN, CHAR_MAX); 
     return EXIT_SUCCESS; 
} 

La vostra situazione è chiamata overflow.

Answer 5

Solo una nota a margine. Da una prospettiva dal basso verso l'alto, lo spostamento bit-saggio (e il mascheramento) si basa sulla lunghezza della parola di un'architettura (espressa in bit). La lunghezza di una parola, varia dall'architettura all'architettura.

See this Wiki page for word lengths by architecture

Se si conosce la lunghezza di parola dell'architettura bersaglio, si può usare bit spostamento di moltiplicazione e divisione (in alcuni casi), più veloce rispetto all'utilizzo operandi.

See this Wiki page for interesting diagrams of bit-shifting

Poiché codice bit-shifted è architettura dipendente, non si può assumere una parte specifica del codice bit spostata funziona allo stesso modo dall'architettura all'architettura. Tuttavia, una volta acquisita familiarità con l'idea di lunghezze di parole diverse per architetture diverse, il bit-shifting diventa meno misterioso e più prevedibile.

Per fortuna, oggi abbiamo lunghezze di parola di 8, 16, 32 e 64 bit e lunghezze di carattere esclusivamente di 8 bit. Nei tempi dell'antica informatica, un'architettura poteva avere una lunghezza di parola 12, o 15, o 23 bit (ecc., Fino alla nausea).