Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Le suffixe `f` des littéraux à virgule flottante

Le suffixe `f` ou `F` donne à un littéral à virgule flottante le type `float` au lieu de `double`. Il influe sur la déduction de type et la résolution de surcharge.

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

Syntaxe

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

Écrivez f ou F directement à la fin du littéral à virgule flottante : 1.0f et 1.0F sont de type float. Le suffixe fait partie du littéral ; ce n’est pas une conversion explicite. Sans suffixe, 1.0 est de type double ; 1.0l et 1.0L sont de type long double.

La notation décimale exige un point ou un exposant : 1.0f et 1e0f sont valides, mais 1f n’est pas une écriture standard d’un littéral de type float. La notation hexadécimale exige un exposant binaire introduit par p ou P, comme dans 0x1p0f.

Dans auto a = 1.0f;, le compilateur déduit float ; avec 1.0, il déduirait double. Si show(float) et show(double) sont disponibles, la correspondance exacte du type l’emporte. Le suffixe n’impose pas le type de toute l’expression : 1.0f + 2.0 est de type double.

0.1f donne une valeur de type float qui n’est pas nécessairement égale à la valeur mathématique exacte 0.1. Une promotion ultérieure vers double conserve cette valeur sans rétablir la précision perdue. En revanche, float x = 0.1; convertit un littéral de type double en float. Le suffixe f ne garantit pas le format IEEE 754 binary32. En C++23, f32 désigne le type distinct std::float32_t et n’est disponible que si l’implémentation prend en charge ce type étendu.

Exemples

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

Résultat

float
double

Les déclarations `static_assert` vérifient les types déduits par `auto`. Chaque appel à `show` choisit la surcharge dont le type du paramètre correspond exactement. Le résultat attendu est donc `float`, puis `double`, sur deux lignes distinctes.

Leçons associées

  • C++ · Leçon 32 · Avancé · Version : 3

Sources