Можно ли отличить 0 от -0?

Это зависит от машины, на которую вы ориентируетесь.

На машине, которая использует представление с дополнением до 2 для целых чисел, нет разницы на битовом уровне между 0 и -0 (они имеют одинаковое представление)

Если бы ваша машина использовала дополнение, вы определенно могли бы

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

Очевидно, мы говорим об использовании встроенной поддержки, процессоры серии x86 имеют встроенную поддержку представления чисел со знаком в дополнении до двух. Использование других представлений определенно возможно, но, вероятно, будет менее эффективным и потребует дополнительных инструкций.

_{(Как также заметил Джерри Коффин: даже если дополнение рассматривалось в основном по историческим причинам, представления величины со знаком все еще довольно распространены и имеют отдельное представление для отрицательного и положительного нуля)}

Для int (в почти универсальном представлении «дополнение до 2») представления 0 и -0 одинаковы. (Они могут отличаться для других числовых представлений, например, IEEE 754 с плавающей запятой.)

Давайте начнем с представления 0 в дополнении до 2 (конечно, существует много других систем и представлений, здесь я имею в виду именно эту), предполагая, что 8-битный ноль:

0000 0000

Теперь давайте перевернем все биты и добавим 1, чтобы получить дополнение до 2:

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

мы получили 0000 0000, и это тоже представление -0.

Но обратите внимание, что в дополнении до 1 знаковый 0 равен 0000 0000, а -0 равен 1111 1111.

Я решил оставить этот ответ, поскольку реализации C и C++ обычно тесно связаны, но на самом деле он не зависит от стандарта C, как я думал. Дело в том, что стандарт C++ не указывает, что происходит в таких случаях. Также имеет значение то, что представления без дополнения до двух чрезвычайно редки в реальном мире, и что даже там, где они существуют, они часто скрывают разницу во многих случаях, а не выставляют ее как нечто, что кто-то может легко обнаружить.

Поведение отрицательных нулей в целочисленных представлениях, в которых они существуют, не так строго определено в стандарте C++, как в стандарте C. Однако он ссылается на стандарт C (ISO/IEC 9899:1999) как на нормативную ссылку на верхнем уровне [1.2].

В стандарте C [6.2.6.2] отрицательный нуль может быть результатом только побитовых операций или операций, в которых отрицательный нуль уже присутствует (например, умножение или деление отрицательного нуля на значение или добавление отрицательного нуля к ноль) - поэтому применение унарного оператора минус к значению нормального нуля, как в вашем примере, гарантированно приведет к нормальному нулю.

Даже в тех случаях, когда может сгенерировать отрицательный нуль, нет гарантии, что они это сделают, даже в системе, которая поддерживает отрицательный нуль:

Не указано, действительно ли эти случаи генерируют отрицательный нуль или нормальный нуль, и становится ли отрицательный нуль нормальным нулем при сохранении в объекте.

Следовательно, мы можем сделать вывод: нет, нет надежного способа обнаружить этот случай. Даже если бы не тот факт, что представления без дополнения до двух очень редко встречаются в современных компьютерных системах.

Стандарт C++, со своей стороны, не упоминает термин «отрицательный нуль» и очень мало обсуждает детали величины со знаком и представления дополнения до единицы, за исключением примечания [3.9.1, абзац 7], что они разрешены.

Если ваша машина имеет разные представления для -0 и +0, то memcmp сможет их различать.

Если присутствуют биты заполнения, на самом деле может быть несколько представлений для значений, отличных от нуля.

В спецификации языка C++ нет такого типа int, как отрицательный ноль.

Единственное значение, которое имеют эти два слова, — это унарный оператор -, применяемый к 0, так же как три плюс пять — это всего лишь бинарный оператор +, применяемый к 3 и 5.

Если бы существовал отдельный отрицательный нуль, дополнение до двух (наиболее распространенное представление типов целых чисел) было бы недостаточным представлением для реализаций C++, поскольку нет способа представить две формы нуля.

Напротив, числа с плавающей запятой (согласно IEEE) имеют отдельные положительные и отрицательные нули. Их можно различить, например, при делении на них 1. Положительный ноль дает положительную бесконечность; отрицательный нуль дает отрицательную бесконечность.

Однако, если существуют разные представления памяти для int 0 (или любого int или любого другого значения любого другого типа), вы можете использовать memcmp, чтобы обнаружить, что:

#include <string>

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

Конечно, если бы это действительно произошло, вне операций с памятью, два значения по-прежнему работали бы точно так же.

Для упрощения мне было легче визуализировать.

Тип int(_32) хранится в 32 битах. 32 бита означают 2^32 = 4294967296 уникальных значений. Таким образом :

Диапазон данных unsigned int: от 0 до 4 294 967 295

В случае отрицательных значений это зависит от того, как они хранятся. В случае

• Дополнение до двух – от 2 147 483 648 до 2 147 483 647
• Дополнение к единице – с 2 147 483 647 до 2 147 483 647

В случае дополнения до единицы существует значение -0.