Se copio un float su un'altra variabile, saranno uguali?

So che usare ==per verificare l'uguaglianza delle variabili in virgola mobile non è un buon modo. Ma voglio solo saperlo con le seguenti dichiarazioni:

float x = ...

float y = x;

assert(y == x)

Dal momento che yviene copiato x, l'affermazione sarà vera?

Oltre al assert(NaN==NaN);caso indicato da kmdreko, puoi avere situazioni con x87-math, quando i float a 80 bit vengono temporaneamente archiviati in memoria e successivamente confrontati con valori che sono ancora memorizzati in un registro.

Possibile esempio minimo, che fallisce con gcc9.2 quando compilato con -O2 -m32:

#include <cassert>

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

Demo Godbolt: https://godbolt.org/z/X-Xt4R

La volatileprobabilmente può essere omesso, se si riesce a creare sufficienti registro pressione di aver yconservato e ricaricato dalla memoria (ma confondere il compilatore abbastanza, di non omettere il confronto tutto insieme).

Vedi riferimento FAQ GCC:

• Perché i risultati in virgola mobile cambiano con livelli di ottimizzazione o diverse versioni del compilatore o diverse architetture di destinazione?

Non sarà vero se lo xè NaN, poiché i confronti su NaNsono sempre falsi (sì, anche NaN == NaN). Per tutti gli altri casi (valori normali, valori non normali, infiniti, zeri) questa affermazione sarà vera.

Il consiglio per evitare i ==float si applica ai calcoli a causa del fatto che i numeri in virgola mobile non sono in grado di esprimere molti risultati esattamente quando usati nelle espressioni aritmetiche. L'assegnazione non è un calcolo e non vi è alcun motivo per cui l'assegnazione produrrebbe un valore diverso dall'originale.

La valutazione di precisione estesa dovrebbe essere un problema se si segue lo standard. Da <cfloat>ereditato da C [5.2.4.2.2.8] ( sottolineatura mia ):

Ad eccezione di assegnazione e cast (che rimuovono tutta la gamma e la precisione extra) , i valori delle operazioni con operandi flottanti e valori soggetti alle solite conversioni aritmetiche e delle costanti fluttuanti vengono valutati in un formato la cui gamma e precisione possono essere maggiori di quelle richieste dal genere.

Tuttavia, come hanno sottolineato i commenti, alcuni casi con determinati compilatori, opzioni di build e obiettivi potrebbero renderlo paradossalmente falso.

Sì, yassumerà sicuramente il valore di x:

[expr.ass]/2: Nell'assegnazione semplice (=), l'oggetto a cui fa riferimento l'operando di sinistra viene modificato ([defns.access]) sostituendo il suo valore con il risultato dell'operando di destra.

Non vi è margine di manovra per l'assegnazione di altri valori.

^{(Altri hanno già sottolineato che un confronto di equivalenza ==valuterà comunque i falsevalori di NaN.)}

Il solito problema con il virgola mobile ==è che è facile non avere abbastanza il valore che pensi di avere. Qui, sappiamo che i due valori, qualunque essi siano, sono gli stessi.

Sì, in tutti i casi (trascurando NaN e problemi x87), questo sarà vero.

Se lo fai memcmpsu di loro sarai in grado di testare l'uguaglianza mentre sarai in grado di confrontare NaN e sNaN. Ciò richiederà anche che il compilatore prenda l'indirizzo della variabile che forzerà il valore in un 32 bit floatanziché in uno a 80 bit. Ciò eliminerà i problemi di x87. La seconda affermazione qui non intende mostrare che ==non confronterà NaN come veri:

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

Si noti che se i NaN hanno una rappresentazione interna diversa (cioè mantissa diversa), il memcmpconfronto non sarà vero.

In casi normali, verrebbe valutato come vero. (o l'istruzione assert non farà nulla)

Modifica :

Per "casi usuali" intendo escludere gli scenari summenzionati (come valori di NaN e unità a virgola mobile 80x87) come indicato da altri utenti.

Data l'ossolenza dei chip 8087 nel contesto odierno, il problema è piuttosto isolato e per la domanda applicabile nell'attuale stato dell'architettura a virgola mobile utilizzata, vale per tutti i casi ad eccezione dei NaN.

(riferimento circa 8087 - https://home.deec.uc.pt/~jlobo/tc/artofasm/ch14/ch143.htm )

Complimenti a @chtz per aver riprodotto un buon esempio e @kmdreko per aver menzionato NaN - non ne erano a conoscenza prima!

Sì, restituirà True sempre, tranne se è NaN . Se il valore della variabile è NaN , restituisce sempre False !