Est-il possible de différencier entre 0 et -0?

Je sais que les valeurs entières 0et -0sont essentiellement les mêmes. Mais, je me demande s'il est possible de les différencier.

Par exemple, comment savoir si une variable a été affectée -0?

bool IsNegative(int num)
{
    // How ?
}

int num = -0;
int additinon = 5;

num += (IsNegative(num)) ? -addition : addition;

La valeur est-elle -0enregistrée dans la mémoire exactement de la même manière que 0?

Cela dépend de la machine que vous ciblez.

Sur une machine qui utilise une représentation complémentaire à 2 pour les entiers, il n'y a pas de différence au niveau du bit entre 0et -0(ils ont la même représentation)

Si votre machine utilisait son complément , vous pourriez certainement

0000 0000   -> signed   0 
1111 1111   -> signed   −0

De toute évidence, nous parlons de l'utilisation du support natif , les processeurs de la série x86 ont un support natif pour la représentation complémentaire à deux des nombres signés. L'utilisation d'autres représentations est certainement possible mais serait probablement moins efficace et nécessiterait plus d'instructions.

_{(Comme JerryCoffin l'a également noté: même si son complément a été considéré principalement pour des raisons historiques, les représentations de magnitude signées sont encore assez courantes et ont une représentation séparée pour le zéro négatif et positif)}

Pour une int(dans la représentation quasi universelle du "complément à 2") les représentations de 0et -0sont les mêmes. (Ils peuvent être différents pour d'autres représentations numériques, par exemple. IEEE 754 à virgule flottante.)

Commençons par représenter 0 dans le complément de 2 (bien sûr, il existe de nombreux autres systèmes et représentations, ici je fais référence à celui-ci), en supposant que 8 bits, zéro est:

0000 0000

Maintenant retournons tous les bits et ajoutons 1 pour obtenir le complément des 2:

1111 1111 (flip)
0000 0001 (add one)
---------
0000 0000

nous avons obtenu 0000 0000, et c'est aussi la représentation de -0.

Mais notez que dans le complément de 1, 0 signé est 0000 0000, mais -0 est 1111 1111.

J'ai décidé de laisser cette réponse car les implémentations C et C ++ sont généralement étroitement liées, mais en fait, cela ne se réfère pas au standard C comme je le pensais. Le fait est que la norme C ++ ne spécifie pas ce qui se passe pour de tels cas. Il est également pertinent que les représentations non complémentaires à deux soient extrêmement rares dans le monde réel et que même là où elles existent, elles cachent souvent la différence dans de nombreux cas plutôt que de l'exposer comme quelque chose que quelqu'un pourrait facilement s'attendre à découvrir.

Le comportement des zéros négatifs dans les représentations entières dans lesquelles ils existent n'est pas aussi rigoureusement défini dans le standard C ++ que dans le standard C. Il cite cependant la norme C (ISO / CEI 9899: 1999) comme référence normative au plus haut niveau [1.2].

Dans la norme C [6.2.6.2], un zéro négatif ne peut être que le résultat d'opérations au niveau du bit, ou d'opérations où un zéro négatif est déjà présent (par exemple, multiplier ou diviser un zéro négatif par une valeur, ou ajouter un zéro négatif à zéro) - l'application de l'opérateur unaire moins à une valeur d'un zéro normal, comme dans votre exemple, est donc garantie pour aboutir à un zéro normal.

Même dans les cas qui peuvent générer un zéro négatif, il n'y a aucune garantie qu'ils le feront, même sur un système qui prend en charge le zéro négatif:

Il n'est pas précisé si ces cas génèrent réellement un zéro négatif ou un zéro normal, et si un zéro négatif devient un zéro normal lorsqu'il est stocké dans un objet.

Par conséquent, nous pouvons conclure: non, il n'existe aucun moyen fiable de détecter ce cas. Même si ce n'est pas pour le fait que les représentations à complément non double sont très rares dans les systèmes informatiques modernes.

Le standard C ++, pour sa part, ne fait aucune mention du terme «zéro négatif», et a très peu de discussion sur les détails de la grandeur signée et des représentations complémentaires de chacun, sauf pour noter [3.9.1 para 7] qu'ils sont autorisés.

Si votre machine a des représentations distinctes pour -0et +0, alors memcmpsera en mesure de les distinguer.

Si des bits de remplissage sont présents, il peut également y avoir plusieurs représentations pour des valeurs autres que zéro.

Dans la spécification du langage C ++, il n'existe aucun int comme zéro négatif .

La seule signification de ces deux mots est l'opérateur unaire -appliqué à 0, tout comme trois plus cinq n'est que l'opérateur binaire +appliqué à 3et 5.

S'il y avait un zéro négatif distinct , le complément à deux (la représentation la plus courante des types entiers) serait une représentation insuffisante pour les implémentations C ++, car il n'y a aucun moyen de représenter deux formes de zéro.

En revanche, les virgules flottantes (suivant IEEE) ont des zéros positifs et négatifs séparés. Ils peuvent être distingués, par exemple, en divisant 1 par eux. Le zéro positif produit l'infini positif; zéro négatif produit l'infini négatif.

Cependant, s'il se trouve qu'il existe différentes représentations mémoire de l'int 0 (ou de tout int, ou de toute autre valeur de tout autre type), vous pouvez utiliser memcmppour découvrir que:

#include <string>

int main() {
    int a = ...
    int b = ...
    if (memcmp(&a, &b, sizeof(int))) {
        // a and b have different representations in memory
    }
}

Bien sûr, si cela se produisait, en dehors des opérations de mémoire directe, les deux valeurs fonctionneraient toujours exactement de la même manière.

Pour simplifier, je l'ai trouvé plus facile à visualiser.

Le type int (_32) est stocké avec 32 bits . 32 bits signifie 2 ^ 32 = 4294967296 valeurs uniques . Donc :

La plage de données int non signée va de 0 à 4 294 967 295

En cas de valeurs négatives, cela dépend de la façon dont elles sont stockées. Au cas où

• Complément à deux: de 2 147 483 648 à 2 147 483 647
• Complément à un - de 2 147 483 647 à 2 147 483 647

En cas de complément de One, la valeur -0 existe.