Если я скопирую float в другую переменную, будут ли они равны?

Я знаю что используя == для проверки равенства переменных с плавающей точкой не очень хороший способ. Но я просто хочу знать это со следующими утверждениями:

float x = ...

float y = x;

assert(y == x)

Так как yэто скопировано x, будет ли утверждение верным?

Кроме assert(NaN==NaN); случая, указанного kmdreko, у вас может быть ситуация с x87-math, когда 80-разрядные числа с плавающей запятой временно сохраняются в памяти и позже сравниваются со значениями, которые все еще хранятся в регистре.

Возможный минимальный пример, который завершается с gcc9.2 при компиляции с -O2 -m32:

#include <cassert>

int main(int argc, char**){
    float x = 1.f/(argc+2);
    volatile float y = x;
    assert(x==y);
}

Демонстрация Godbolt: https://godbolt.org/z/X-Xt4R

volatile, Вероятно , может быть опущена, если вам удастся создать достаточное количество регистров давления , чтобы иметьy сохраняются и загружаются из памяти (но путать компилятор достаточно, чтобы не опускать сравнение все вместе).

См. Ссылку GCC FAQ:

• Почему результаты с плавающей запятой меняются в зависимости от уровней оптимизации, разных версий компилятора или разных целевых архитектур?

Это не будет верно , если xэто NaN, так как сравнения на NaNэто всегда ложно (да, даже NaN == NaN). Для всех остальных случаев (нормальные значения, субнормальные значения, бесконечности, нули) это утверждение будет верным.

Рекомендация по избежанию операций с плавающей точкой ==применима к вычислениям, поскольку числа с плавающей запятой не могут точно выразить многие результаты при использовании в арифметических выражениях. Присвоение не является расчетом, и нет причин, по которым присваивание могло бы дать значение, отличное от исходного.

Оценка расширенной точности не должна быть проблемой при соблюдении стандарта. Из <cfloat>унаследованного от C [5.2.4.2.2.8] ( выделено мое ):

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

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

Да, yбезусловно, примет значение x:

[expr.ass]/2: В простом присваивании (=) объект, на который ссылается левый операнд, изменяется ([defns.access]), заменяя его значение результатом правого операнда.

Не существует возможности для других назначаемых значений.

^{(Другие уже указывали, что сравнение эквивалентности ==, тем не менее, будет оценивать falseдля значений NaN.)}

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

Да, во всех случаях (без учета NaN и проблем с x87) это будет правдой.

Если вы сделаете для memcmpних проверку, вы сможете проверить на равенство и одновременно сравнить NaN и sNaN. Это также потребует от компилятора взять адрес переменной, которая приведет значение к 32-битному, floatа не к 80-битному. Это устранит проблемы с x87. Второе утверждение здесь не предназначено для демонстрации того, что ==NaN не будут сравниваться как истинные:

#include <cmath>
#include <cassert>
#include <cstring>

int main(void)
{
    float x = std::nan("");
    float y = x;
    assert(!std::memcmp(&y, &x, sizeof(float)));
    assert(y == x);
    return 0;
}

Обратите внимание, что если NaN имеют другое внутреннее представление (то есть различную мантиссу), memcmpсравнение не будет истинным.

В обычных случаях это будет оценено как истинное. (или утверждение assert ничего не сделает)

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

Под «обычными случаями» я подразумеваю исключение вышеупомянутых сценариев (таких как значения NaN и единицы с плавающей запятой 80x87), как указано другими пользователями.

Принимая во внимание устаревшее количество микросхем 8087 в сегодняшнем контексте, проблема является довольно изолированной, и вопрос применим к текущему состоянию используемой архитектуры с плавающей запятой, что справедливо для всех случаев, за исключением NaN.

(ссылка около 8087 - https://home.deec.uc.pt/~jlobo/tc/artofasm/ch14/ch143.htm )

Спасибо @chtz за хороший пример и @kmdreko за упоминание NaNs - раньше о них не знали!

Да, он вернет True всегда, кроме случаев, когда это NaN . Если значение переменной равно NaN, оно всегда возвращает False !