Se eu copiar um float para outra variável, eles serão iguais?

Eu sei que usar ==para verificar a igualdade de variáveis ​​de ponto flutuante não é uma boa maneira. Mas eu só quero saber isso com as seguintes declarações:

float x = ...

float y = x;

assert(y == x)

Desde que yé copiado x, a afirmação será verdadeira?

além da assert(NaN==NaN); caso apontado por kmdreko, você pode ter situações com x87-math, quando flutuadores de 80 bits são temporariamente armazenados na memória e, posteriormente, comparados com valores que ainda são armazenados dentro de um registro.

Possível exemplo mínimo, que falha com o gcc9.2 quando compilado com -O2 -m32:

#include <cassert>

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

Demonstração Godbolt: https://godbolt.org/z/X-Xt4R

O volatileprovavelmente pode ser omitido, se você conseguir criar registo pressão suficiente para tery armazenado e recarregado a partir da memória (mas confundir o suficiente compilador, não omitir a comparação todos juntos).

Consulte a referência de perguntas frequentes do GCC:

• Por que os resultados de ponto flutuante mudam com os níveis de otimização ou diferentes versões do compilador ou diferentes arquiteturas de destino?

Não será verdade se xfor NaN, pois as comparações sempreNaN são falsas (sim, até NaN == NaN). Para todos os outros casos (valores normais, valores subnormais, infinitos, zeros), essa afirmação será verdadeira.

O conselho para evitar ==flutuações se aplica aos cálculos devido ao fato de os números de ponto flutuante serem incapazes de expressar muitos resultados exatamente quando usados ​​em expressões aritméticas. A atribuição não é um cálculo e não há razão para que a atribuição produza um valor diferente do original.

A avaliação de precisão estendida deve ser um problema, se o padrão for seguido. De <cfloat>herdado de C [5.2.4.2.2.8] ( ênfase minha ):

Exceto pela atribuição e conversão (que removem toda a faixa e precisão extras) , os valores de operações com operandos flutuantes e sujeitos às conversões aritméticas usuais e de constantes flutuantes são avaliados para um formato cujo alcance e precisão podem ser maiores do que o exigido pelo tipo.

No entanto, como os comentários apontaram, alguns casos com certos compiladores, opções de construção e destinos podem tornar isso paradoxalmente falso.

Sim, ycertamente assumirá o valor de x:

[expr.ass]/2: Na atribuição simples (=), o objeto referido pelo operando esquerdo é modificado ([defns.access]) substituindo seu valor pelo resultado do operando direito.

Não há margem de manobra para outros valores a serem atribuídos.

^{(Outros já apontaram que uma comparação de equivalência ==será avaliada falsepara os valores de NaN.)}

O problema usual do ponto flutuante ==é que é fácil não ter exatamente o valor que você pensa ter. Aqui, sabemos que os dois valores, sejam eles quais forem, são os mesmos.

Sim, em todos os casos (desconsiderando os problemas de NaNs e x87), isso será verdade.

Se você fizer um teste memcmpneles, poderá testar a igualdade e comparar NaNs e sNaNs. Isso também exigirá que o compilador leve o endereço da variável que forçará o valor a 32 bits em floatvez de 80 bits. Isso eliminará os problemas do x87. A segunda afirmação aqui pretende falhar ao mostrar que ==não comparará os NaNs como verdadeiros:

#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;
}

Observe que se os NaNs tiverem uma representação interna diferente (por exemplo, mantissa diferente), o valor memcmpnão será verdadeiro.

Em casos usuais, seria avaliado como verdadeiro. (ou a declaração de afirmação não fará nada)

Editar :

Por "casos usuais", quero dizer, estou excluindo os cenários acima mencionados (como valores de NaN e unidades de ponto flutuante de 80x87), conforme apontado por outros usuários.

Dada a obsolescência dos chips 8087 no contexto atual, a questão é bastante isolada e, para que a questão seja aplicável no estado atual da arquitetura de ponto flutuante usada, é verdadeira para todos os casos, exceto para NaNs.

(referência sobre 8087 - https://home.deec.uc.pt/~jlobo/tc/artofasm/ch14/ch143.htm )

Parabéns ao @chtz por reproduzir um bom exemplo e ao @kmdreko por mencionar os NaNs - não os conhecia antes!

Sim, ele retornará True sempre, exceto se for NaN . Se o valor da variável for NaN , ele sempre retornará False !