Предупреждение C ++: деление двойного на ноль

Случай 1:

#include <iostream>

int main()
{
    double d = 15.50;
    std::cout<<(d/0.0)<<std::endl;
}

Компилируется без предупреждений и выводов inf. Хорошо, C ++ может обрабатывать деление на ноль ( посмотреть вживую ).

Но,

Случай 2:

#include <iostream>

int main()
{
    double d = 15.50;
    std::cout<<(d/0)<<std::endl;
}

Компилятор выдает следующее предупреждение ( посмотрите его вживую ):

warning: division by zero [-Wdiv-by-zero]
     std::cout<<(d/0)<<std::endl;

Почему компилятор выдает предупреждение во втором случае?

Есть 0 != 0.0?

Редактировать:

#include <iostream>

int main()
{
    if(0 == 0.0)
        std::cout<<"Same"<<std::endl;
    else
        std::cout<<"Not same"<<std::endl;
}

вывод:

Same

Деление с плавающей запятой на ноль хорошо определено IEEE и дает бесконечность (положительную или отрицательную в зависимости от значения числителя ^{(или NaN± 0)} ).

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

Однако в этом случае, поскольку числитель - это double, divisor ( 0) также должен быть повышен до двойного, и нет причин давать здесь предупреждение, не давая предупреждения, 0.0поэтому я думаю, что это ошибка компилятора.

В стандартном C ++ оба случая являются неопределенным поведением . Может случиться что угодно, включая форматирование жесткого диска. Вы не должны ожидать или полагаться на «return inf. Ok» или любое другое поведение.

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

Из стандарта C ++ 17 [expr.mul] / 4:

Бинарный /оператор возвращает частное, а бинарный %оператор возвращает остаток от деления первого выражения на второе. Если второй операнд /или %равен нулю, поведение не определено.

Лучше всего, чтобы ответить на этот конкретный вопрос , компилятор выдает предупреждение перед преобразованием intв double.

Итак, шаги будут такими:

1. Анализировать выражение
2. Арифметика оператор /(T, T2) , где T=double, T2=int.
3. Проверьте, что std::is_integral<T2>::valueесть trueи b == 0- это вызывает предупреждение.
4. Создать предупреждение
5. Выполнить неявное преобразование T2вdouble
6. Выполните четко определенное деление (поскольку компилятор решил использовать IEEE 754).

Это, конечно, предположение и основано на спецификациях, определенных компилятором. Со стандартной точки зрения, мы имеем дело с возможным неопределенным поведением.

Обратите внимание, что это ожидаемое поведение в соответствии с документацией GCC
(кстати, похоже, что этот флаг нельзя использовать явно в GCC 8.1)

-Wdiv-by-zero
Предупредить о целочисленном делении на ноль во время компиляции. Это по умолчанию. Чтобы запретить отображение предупреждающих сообщений, используйте -Wno-div-by-zero. О делении с плавающей запятой на ноль не предупреждают, так как это может быть законным способом получения бесконечностей и NaN.

В этом ответе я не буду вдаваться в разгром UB / not UB.

Я просто хочу указать на это, 0и 0.0 они разные, несмотря на то, что их0 == 0.0 оценка истинна. 0является intбуквальным и 0.0является doubleбуквальным.

Однако в этом случае конечный результат тот же: d/0деление с плавающей запятой, потому что dоно double и поэтому 0неявно преобразуется в double.

Я считаю , что foo/0и foo/0.0это не то же самое. А именно, результирующий эффект первого (целочисленное деление или деление с плавающей запятой) сильно зависит от типа foo, в то время как то же самое не верно для второго (это всегда будет деление с плавающей запятой).

Не имеет значения, является ли какой-либо из двух UB. Цитата из стандарта:

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

(Акцент мой)

Обратите внимание на предупреждение « предлагать круглые скобки вокруг присваивания, используемого в качестве истинного значения »: способ сообщить компилятору, что вы действительно хотите использовать результат присваивания, явиться явным и добавить круглые скобки вокруг присваивания. Результирующий оператор имеет тот же эффект, но сообщает компилятору, что вы знаете, что делаете. То же самое можно сказать и о foo/0.0: поскольку вы явно указываете компилятору «Это деление с плавающей запятой», используя 0.0вместо 0, компилятор доверяет вам и не выдаст предупреждение.

Это похоже на ошибку gcc, в документации -Wno-div-by-zero четко сказано :

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

и после обычных арифметических преобразований, описанных в [expr.arith.conv], оба операнда будут двойными :

Многие бинарные операторы, которые ожидают операндов арифметического или перечислительного типа, вызывают преобразования и выдают типы результатов аналогичным образом. Цель состоит в том, чтобы получить общий тип, который также является типом результата. Этот шаблон называется обычными арифметическими преобразованиями, которые определяются следующим образом:

...

- В противном случае, если один из операндов является двойным, другой должен быть преобразован в двойной.

и [expr.mul] :

Операнды * и / должны иметь арифметический тип или тип перечисления без области действия; операнды% должны иметь целочисленный или незаданный тип перечисления. Обычные арифметические преобразования выполняются с операндами и определяют тип результата.

Что касается того, является ли деление с плавающей запятой на ноль неопределенным поведением, и как разные реализации с этим справляются, мой ответ здесь . TL; DR; Похоже, что gcc соответствует Приложению F относительно деления с плавающей запятой на ноль, поэтому undefined здесь не играет роли. Для clang ответ был бы другим.

Деление с плавающей запятой на ноль ведет себя иначе, чем целочисленное деление на ноль.

Стандарт IEEE с плавающей запятой различает + inf и -inf, в то время как целые числа не могут хранить бесконечность. Целочисленное деление на нулевой результат - неопределенное поведение. Деление с плавающей запятой на ноль определяется стандартом с плавающей запятой и приводит к + inf или -inf.