Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Il suffisso `f` dei letterali in virgola mobile

Il suffisso `f` o `F` assegna a un letterale in virgola mobile il tipo `float` invece di `double`. Questo incide sulla deduzione del tipo e sulla risoluzione degli overload.

Versione: ISO C++23; implementation support may vary

Sintassi

1.0f        // float
1.0F        // float
1e0f        // float: decimal exponent, no decimal point
0x1p0f      // float: hexadecimal form with a binary exponent
1.0         // double
1.0L        // long double

Scrivi f o F direttamente alla fine del letterale in virgola mobile: 1.0f e 1.0F hanno tipo float. Il suffisso fa parte del letterale, non è una conversione esplicita. Senza suffisso, 1.0 ha tipo double; 1.0l e 1.0L hanno tipo long double.

La notazione decimale richiede un punto o un esponente: 1.0f e 1e0f sono validi, ma 1f non è una notazione standard per un letterale di tipo float. La notazione esadecimale richiede un esponente binario introdotto da p o P, come in 0x1p0f.

In auto a = 1.0f; il compilatore deduce float; con 1.0 dedurrebbe double. Se sono disponibili show(float) e show(double), prevale la corrispondenza esatta del tipo. Il suffisso non impone il tipo dell’intera espressione: 1.0f + 2.0 ha tipo double.

0.1f produce un valore di tipo float che non coincide necessariamente con il valore matematico esatto 0.1. Una successiva promozione a double conserva quel valore, ma non recupera la precisione persa. Invece float x = 0.1; converte un letterale di tipo double in float. Il suffisso f non garantisce il formato IEEE 754 binary32. In C++23, f32 indica il tipo distinto std::float32_t ed è disponibile solo se l’implementazione supporta quel tipo esteso.

Esempi

#include <iostream>
#include <type_traits>

void show(float)  { std::cout << "float\n"; }
void show(double) { std::cout << "double\n"; }

int main() {
    auto a = 1.0f;
    auto b = 1.0;
    static_assert(std::is_same_v<decltype(a), float>);
    static_assert(std::is_same_v<decltype(b), double>);

    show(a);
    show(b);
}

Risultato

float
double

Le dichiarazioni `static_assert` controllano i tipi dedotti da `auto`. Ogni chiamata a `show` seleziona l’overload con il tipo di parametro esatto. L’output atteso è quindi `float` seguito da `double`, su righe separate.

Lezioni correlate

  • C++ · Lezione 32 · Avanzato · Versione: 3

Fonti