Comment puis-je vérifier si un entier signé est positif?

Question

En utilisant des opérateurs au niveau du bit et je suppose que l'addition et la soustraction, comment puis-je vérifier si un entier signé est positif (spécifiquement, non négatif et non nul)? Je suis sûr que la réponse à cette question est très simple, mais elle ne vient tout simplement pas à moi.

Answer 1

Si vous voulez vraiment un « est strictement positif » prédicat pour int n sans utiliser conditionals (en supposant complément à 2):

• -n aura le signe (en haut) bit set si n était strictement positif et clair dans tous les autres cas à l'exception den == INT_MIN;
• ~n aura le bit de signe défini si n était strictement positif, ou 0, et clair dans tous les autres cas, y compris n == INT_MIN;
• ... donc -n & ~n aura le bit de signe fixé si n était strictement positif, et effacer dans tous les autres cas.

Appliquer un non signé changement pour en faire un 0/1 réponse:

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

EDIT: comme points cafs dans les commentaires, -n provoque un débordement lorsque n == INT_MIN (en supposant toujours le complément de 2). La norme C permet au programme d'échouer dans ce cas (par exemple, vous pouvez activer les interruptions pour le débordement signé en utilisant GCC avec l'option -ftrapv). Casting n à unsigned résout le problème (l'arithmétique non signée ne provoque pas de débordements). Donc une amélioration serait:

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

Answer 2

Vérifiez le bit le plus significatif. 0 est positif, 1 est négatif.

Answer 3

Considérez comment la signature est représentée. Souvent, il est fait avec deux-complément ou avec un simple bit signe - Je pense que ces deux pourraient être vérifiés avec un simple et logique.

Answer 4

Vérifiez que n'est pas 0 et le bit le plus significatif est 0, quelque chose comme:

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

Answer 5

Si vous ne pouvez pas utiliser les opérateurs de comparaison évidentes, alors vous devez travailler plus dur:

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

Le premier terme vérifie que la valeur n'est pas nulle; la seconde vérifie que la valeur n'a pas le bit de début défini. Cela devrait fonctionner pour les entiers en complément de 2, en complément de 1 ou en nombre de signes.