Floating-point literal

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

C++ language

General topics
Preprocessor Comments	Keywords Escape sequences
Flow control
Conditional execution statements
if	switch
Iteration statements (loops)
for range-for (C++11)	while do-while
Jump statements
continue - break	goto - return
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications (until C++20)
noexcept specifier (C++11)
Exceptions
throw-expression	try-catch block
Namespaces
Namespace declaration	Namespace aliases
Types
Fundamental types Enumeration types Function types	Class/struct types Union types
Specifiers
decltype (C++11) auto (C++11) alignas (C++11)	const/volatile constexpr (C++11)
Storage duration specifiers
Initialization
Default initialization Value initialization Zero initialization Copy initialization Direct initialization	Aggregate initialization List initialization (C++11) Constant initialization Reference initialization

Expressions
Value categories Order of evaluation	Operators Operator precedence
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
new expression	delete expression
Classes
Class declaration Constructors this pointer	Access specifiers friend specifier
Class-specific function properties
Virtual function override specifier (C++11) final specifier (C++11)	explicit (C++11) static
Special member functions
Default constructor Copy constructor Move constructor (C++11)	Copy assignment Move assignment (C++11) Destructor
Templates
Class template Function template	Template specialization Parameter packs (C++11)
Miscellaneous
Inline assembly	History of C++

 

Expressions

General

value categories (lvalue, rvalue, xvalue)

order of evaluation (sequence points)

constant expressions

unevaluated expressions

primary expressions

lambda-expression(C++11)

Literals

integer literals

floating-point literals

boolean literals

character literals including escape sequences

string literals

null pointer literal(C++11)

user-defined literal(C++11)

Operators

Assignment operators: a=b, a+=b, a-=b, a*=b, a/=b, a%=b, a&=b, a|=b, a^=b, a<<=b, a>>=b

Increment and decrement: ++a, --a, a++, a--

Arithmetic operators: +a, -a, a+b, a-b, a*b, a/b, a%b, ~a, a&b, a|b, a^b, a<<b, a>>b

Logical operators: a||b, a&&b, !a

Comparison operators: a==b, a!=b, a<b, a>b, a<=b, a>=b, a<=>b(C++20)

Member access operators: a[b], *a, &a, a->b, a.b, a->*b, a.*b

Other operators: a(...), a,b, a?b:c

new-expression

delete-expression

throw-expression

alignof

sizeof

sizeof...(C++11)

typeid

noexcept(C++11)

Fold expression(C++17)

Alternative representations of operators

Precedence and associativity

Operator overloading

Default comparisons(C++20)

Conversions

Implicit conversions

const_cast

static_cast

reinterpret_cast

dynamic_cast

Explicit conversions (T)a, T(a)

User-defined conversion

 

Floating-point literal defines a compile-time constant whose value is specified in the source file.

Syntax

digit-sequence decimal-exponent suffix(optional)	(1)
digit-sequence . decimal-exponent(optional) suffix(optional)	(2)
digit-sequence(optional) . digit-sequence decimal-exponent(optional) suffix(optional)	(3)
0x | 0X hex-digit-sequence hex-exponent suffix(optional)	(4)	(since C++17)
0x | 0X hex-digit-sequence . hex-exponent suffix(optional)	(5)	(since C++17)
0x | 0X hex-digit-sequence(optional) . hex-digit-sequence hex-exponent suffix(optional)	(6)	(since C++17)

1) digit-sequence representing a whole number without a decimal separator, in this case the exponent is not optional: 1e10, 1e-5L

2) digit-sequence representing a whole number with a decimal separator, in this case the exponent is optional: 1., 1.e-2

3) digit-sequence representing a fractional number. The exponent is optional: 3.14, .1f, 0.1e-1L

4) Hexadecimal digit-sequence representing a whole number without a radix separator. The exponent is never optional for hexadecimal floating-point literals: 0x1ffp10, 0X0p-1

5) Hexadecimal digit-sequence representing a whole number with a radix separator. The exponent is never optional for hexadecimal floating-point literals: 0x1.p0, 0xf.p-1

6) Hexadecimal digit-sequence representing a fractional number with a radix separator. The exponent is never optional for hexadecimal floating-point literals: 0x0.123p-1, 0xa.bp10l

decimal-exponent has the form

e | E exponent-sign(optional) digit-sequence

hex-exponent has the form

p | P exponent-sign(optional) digit-sequence		(since C++17)

exponent-sign, if present, is either + or -

suffix, if present, is one of f, F, l, or L. The suffix determines the type of the floating-point literal:

• (no suffix) defines double
• f F defines float
• l L defines long double

Optional single quotes (') may be inserted between the digits as a separator; they are ignored during compilation.

(since C++14)

Explanation

Decimal scientific notation is used, meaning that the value of the floating-point literal is the significand multiplied by the number 10 raised to the power of decimal-exponent. E.g. the mathematical meaning of 123e4 is 123×10⁴.

If the floating literal begins with the character sequence 0x or 0X, the floating literal is a hexadecimal floating literal. Otherwise, it is a decimal floating literal. For a hexadecimal floating literal, the significand is interpreted as a hexadecimal rational number, and the digit-sequence of the exponent is interpreted as the integer power of 2 to which the significand has to be scaled. double d = 0x1.4p3; // hex fraction 1.4 (decimal 1.25) scaled by 2^3, that is 10.0

(since C++17)

Notes

The hexadecimal floating-point literals were not part of C++ until C++17, although they can be parsed and printed by the I/O functions since C++11: both C++ I/O streams when std::hexfloat is enabled and the C I/O streams: std::printf, std::scanf, etc. See std::strtof for the format description.

Example

Run this code

#include <iostream>
#include <iomanip>
#include <limits>
#include <typeinfo>
 
int main()
{
  std::cout 
    << "Literal       "   << "Printed value"
    << "\n58.           " << 58.          // double
    << "\n4e2           " << 4e2          // double
    << "\n123.456e-67   " << 123.456e-67  // double
    << "\n123.456e-67f  " << 123.456e-67f // float, truncated to zero
    << "\n.1E4f         " << .1E4f        // float
    << "\n0x10.1p0      " << 0x10.1p0     // double
    << "\n0x1p5         " << 0x1p5        // double
    << "\n0x1e5         " << 0x1e5        // integer literal, not floating-point
    << "\n3.14'15'92    " << 3.14'15'92   // double, single quotes ignored (C++14)
    << "\n1.18e-4932l   " << 1.18e-4932l  // long double
    << std::setprecision(39)
    << "\n3.4028234e38f " << 3.4028234e38f // float
    << "\n3.4028234e38  " << 3.4028234e38  // double
    << "\n3.4028234e38l " << 3.4028234e38l // long double
    << '\n';
 
  static_assert(3.4028234e38f == std::numeric_limits<float>::max());
 
  static_assert(3.4028234e38f ==  // ends with 4
                3.4028235e38f);   // ends with 5
 
  static_assert(3.4028234e38 !=   // ends with 4
                3.4028235e38);    // ends with 5
 
  // Both floating-point constants below are 3.4028234e38
  static_assert(3.4028234e38f !=  // a float (then promoted to double) 
                3.4028234e38);    // a double
}

Possible output:

Literal       Printed value
58.           58
4e2           400
123.456e-67   1.23456e-65
123.456e-67f  0
.1E4f         1000
0x10.1p0      16.0625
0x1p5         32
0x1e5         485
3.14'15'92    3.14159
1.18e-4932l   1.18e-4932
3.4028234e38f 340282346638528859811704183484516925440
3.4028234e38  340282339999999992395853996843190976512
3.4028234e38l 340282339999999999995912555211526242304

See also

user-defined literals(C++11)

literals with user-defined suffix