KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Het achtervoegsel `f` bij zwevendekommaliteralen

Met `f` of `F` krijgt een zwevendekommaliteraal het type `float` in plaats van het standaardtype `double`. Dat beïnvloedt typeafleiding en de keuze van een overload.

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

Syntax

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

Schrijf f of F direct achter het zwevendekommaliteraal: 1.0f en 1.0F hebben het type float. Het achtervoegsel hoort bij het literaal en is geen cast. Zonder achtervoegsel heeft 1.0 het type double; 1.0l en 1.0L hebben het type long double.

Een decimale notatie vereist een punt of een exponent: 1.0f en 1e0f zijn geldig, maar 1f is geen standaardnotatie voor een float-literaal. Een hexadecimale notatie vereist een binaire exponent die begint met p of P, zoals in 0x1p0f.

In auto a = 1.0f; leidt de compiler float af; met 1.0 zou hij double afleiden. Als show(float) en show(double) beide beschikbaar zijn, wint de exacte typeovereenkomst. Het achtervoegsel bepaalt niet het type van de hele expressie: 1.0f + 2.0 heeft het type double.

0.1f levert een float-waarde op die niet exact gelijk hoeft te zijn aan de wiskundige waarde 0.1. Latere promotie naar double behoudt die waarde, maar herstelt geen verloren precisie. Daarentegen converteert float x = 0.1; een double-literaal naar float. Het achtervoegsel f garandeert het IEEE 754 binary32-formaat niet. In C++23 duidt f32 het aparte type std::float32_t aan en is het achtervoegsel alleen beschikbaar als de implementatie dat uitgebreide type ondersteunt.

Voorbeelden

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

Resultaat

float
double

De `static_assert`-declaraties controleren de typen die `auto` afleidt. Elke aanroep van `show` kiest de overload met het exact overeenkomende parametertype. De verwachte uitvoer is daarom `float` en daarna `double`, elk op een eigen regel.

Gerelateerde lessen

  • C++ · Les 32 · Gevorderd · Versie: 3

Bronnen