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 doubleSchrijf 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
- Floating-point literals [lex.fcon]
- Fundamental types [basic.fundamental]
- <stdfloat> synopsis [stdfloat.syn]
- Placeholder type deduction [dcl.type.auto.deduct]
- Ranking implicit conversion sequences [over.ics.rank]
- Floating-point promotion [conv.fpprom]
- Floating-point conversions [conv.double]
- Usual arithmetic conversions [expr.arith.conv]