cosa succede quando mischio tipi firmati e non firmati?

Question

Sto studiando il linguaggio C++ e ho qualche dubbio sulla conversione del tipo, mi può spiegare che cosa accade in un'espressione come questa:

unsigned int u = 10; 
int a = -42; 
std::cout << u - a << std::endl; 

Qui so che il risultato sarà 52 Se si applica la regole quando abbiamo due operatori matematici. Ma mi chiedo che cosa succede quando il compilatore per convertire un valore in un non firmato crea un temporaneo di tipo senza segno, cosa succede dopo? L'espressione ora dovrebbe essere 10 -4294967254.

Answer 1

In termini semplici, se si mescolano i tipi dello stesso valore (nella sequenza di int, long int, long long int), il tipo unsigned "vince" ed i calcoli vengono eseguiti all'interno di quel tipo unsigned . Il risultato è dello stesso tipo senza segno.

Se si mescolano tipi di rango diverso, il tipo più elevato "vince", se può rappresentare tutti i valori del tipo con classificazione inferiore. I calcoli vengono eseguiti all'interno di quel tipo. Il risultato è di quel tipo.

Infine, se il tipo con classificazione più alta non può rappresentare tutti i valori di tipo con classificazione inferiore, viene utilizzata la versione senza segno del tipo con classificazione più alta. Il risultato è di quel tipo.

Nel tuo caso si tipi misti dello stesso valore (int e unsigned int), il che significa che l'intera espressione viene valutata all'interno unsigned int tipo. L'espressione, come hai affermato correttamente, è ora 10 - 4294967254 (per 32 bit int). I tipi non firmati rispettano le regole dell'aritmetica modulo con 2^32 (4294967296) come modulo. Se si calcola attentamente il risultato (che può essere espresso aritmeticamente come 10 - 4294967254 + 4294967296), risulterà come previsto 52.

Answer 2

1) A causa di regole di promozione standard, il signed tipo a viene promosso a un unsigned tipo prima di sottrazione. Che la promozione avviene secondo questa regola (C++ standard da 4,7/2):

Se il tipo di destinazione è senza segno, il valore risultante è il meno intero senza segno congruente al numero intero sorgente (modulo 2n dove n è la numero di bit utilizzati per rappresentare il tipo senza segno).

Algebricamente a diventa un numero positivo molto ampio e sicuramente maggiore di u.

2) u - a è un anonimo temporanea e sarà un unsigned tipo . (È possibile verificare ciò scrivendo auto t = u - a e ispezionando il tipo di t nel debugger.) Matematicamente questo sarà un numero negativo ma sulla conversione implicita al tipo unsigned, viene invocata una regola wraparound simile a quella precedente.

In breve, le due operazioni di conversione hanno effetti uguali e opposti e il risultato sarà 52. In pratica, il compilatore potrebbe ottimizzare tutte queste conversioni.

Answer 3

ecco il codice smontare dice:

esso primi set -42 al suo complemento e fanno l'operazione sub. in modo che il risultato è 10 + 42 0x0000000000400835 <+8>: movl $0xa,-0xc(%rbp) 0x000000000040083c <+15>: movl $0xffffffd6,-0x8(%rbp) 0x0000000000400843 <+22>: mov -0x8(%rbp),%eax 0x0000000000400846 <+25>: mov -0xc(%rbp),%edx 0x0000000000400849 <+28>: sub %eax,%edx 0x000000000040084b <+30>: mov %edx,%eax