Come posso verificare se un intero con segno è positivo?

Question

Usando operatori bit a bit e suppongo addizione e sottrazione, come posso verificare se un intero con segno è positivo (in particolare, non negativo e non zero)? Sono sicuro che la risposta a questo è molto semplice, ma non mi viene in mente.

Answer 1

Se si vuole veramente un "è strettamente positivo" predicato per int n senza usare condizionali (supponendo complemento a 2):

• -n avrà il segno (in alto) è impostato il bit se n era strettamente positivo, e chiaro in tutti gli altri casi eccetton == INT_MIN;
• ~n avrà il bit di segno impostato se n era strettamente positiva, o 0, e chiaro in tutti gli altri casi, tra cui n == INT_MIN;
• ... quindi -n & ~n avrà il bit di segno impostato se n era strettamente positivo e chiaro in tutti gli altri casi.

Applicare un senza segno passaggio a trasformare questo in un 0/1 risposta:

int strictly_positive = (unsigned)(-n & ~n) >> ((sizeof(int) * CHAR_BIT) - 1); 

EDIT: come punti caf nei commenti, -n causa un overflow quando n == INT_MIN (ancora assumendo complemento a 2). Lo standard C consente al programma di fallire in questo caso (ad esempio, è possibile abilitare trap per overflow con segno tramite GCC con l'opzione -ftrapv). La trasmissione n alle correzioni senza segno risolve il problema (l'aritmetica non firmata non causa overflow). Quindi, un miglioramento sarebbe:

unsigned u = (unsigned)n; 
int strictly_positive = (-u & ~u) >> ((sizeof(int) * CHAR_BIT) - 1); 

Answer 2

Controllare il bit più significativo. 0 è positivo, 1 è negativo.

Answer 3

Considerare come viene rappresentata la firma. Spesso è fatto con complemento a due o con un semplice segno bit - Penso che entrambi potrebbero essere controllati con una logica semplice e.

Answer 4

Controllare che non è 0 e il bit più significativo è 0, qualcosa di simile:

int positive(int x) { 
    return x && (x & 0x80000000); 
} 

Answer 5

Se non è possibile utilizzare gli operatori di confronto evidenti, poi si deve lavorare di più:

int i = anyValue; 
if (i && !(i & (1U << (sizeof(int) * CHAR_BIT - 1)))) 
    /* I'm almost positive it is positive */ 

Il primo termine controlla che il valore non sia zero; il secondo controlla che il valore non abbia il bit iniziale impostato. Questo dovrebbe funzionare per i complementi a 2 complementi, a complemento d'oro oa numeri di segno.