Floating-point literals

Binary floating-point literals

A real binary floating-point constant consists of the following:

• An integral part
• A decimal point
• A fractional part
• An exponent part
• An optional suffix

Both the integral and fractional parts are made up of decimal digits. You can omit either the integral part or the fractional part, but not both. You can omit either the decimal point or the exponent part, but not both.

Binary floating-point literal syntax

                       .-------.                              
                       V       |                              
>>-+-+-----------+--.----digit-+--+--------------+-+--+---+----><
   | | .-------. |                '-| exponent |-' |  +-f-+   
   | | V       | |                                 |  +-F-+   
   | '---digit-+-'                                 |  +-l-+   
   | .-------.                                     |  '-L-'   
   | V       |                                     |          
   +---digit-+--.--+--------------+----------------+          
   |               '-| exponent |-'                |          
   | .-------.                                     |          
   | V       |                                     |          
   '---digit-+--| exponent |-----------------------'          

Exponent

                  .-------.   
                  V       |   
|--+-e-+--+----+----digit-+-------------------------------------|
   '-E-'  +-+--+              
          '- --'              

The suffix f or F indicates a type of float, and the suffix l or L indicates a type of long double. If a suffix is not specified, the floating-point constant has a type double.

A plus (+) or minus (-) symbol can precede a floating-point literal. However, it is not part of the literal; it is interpreted as a unary operator.

The following are examples of floating-point literals:

Hexadecimal floating-point literals (C only)

Real hexadecimal floating constants, which are a C99 feature, consist of the following parts.

• a hexadecimal prefix
• a significant part
• a binary exponent part
• an optional suffix

The significant part represents a rational number and is composed of the following:

• a sequence of hexadecimal digits (whole-number part)
• an optional fraction part

The optional fraction part is a period followed by a sequence of hexadecimal digits.

The exponent part indicates the power of 2 to which the significant part is raised, and is an optionally signed decimal integer. The type suffix is optional. The full syntax is as follows:

Hexadecimal floating-point literal syntax

>>-+-0x-+------------------------------------------------------->
   '-0X-'   

     .------------------.     .------------------.                   
     V                  |     V                  |                   
>--+---+--------------+-+--.----+-digit_0_to_f-+-+--| exponent |-+-->
   |   +-digit_0_to_f-+         '-digit_0_to_F-'                 |   
   |   '-digit_0_to_F-'                                          |   
   | .------------------.                                        |   
   | V                  |                                        |   
   +---+-digit_0_to_f-+-+--.--| exponent |-----------------------+   
   |   '-digit_0_to_F-'                                          |   
   | .------------------.                                        |   
   | V                  |                                        |   
   '---+-digit_0_to_f-+-+--| exponent |--------------------------'   
       '-digit_0_to_F-'                                              

>--+---+-------------------------------------------------------><
   +-f-+   
   +-F-+   
   +-l-+   
   '-L-'   

Exponent

                  .--------------.   
                  V              |   
|--+-p-+--+----+----digit_0_to_9-+------------------------------|
   '-P-'  +-+--+                     
          '- --'                     

The suffix f or F indicates a type of float, and the suffix l or L indicates a type of long double. If a suffix is not specified, the floating-point constant has a type double. You can omit either the whole-number part or the fraction part, but not both. The binary exponent part is required to avoid the ambiguity of the type suffix F being mistaken for a hexadecimal digit.

Complex literals

Complex literals, which were introduced in the C99 standard, are constructed in two parts: the real part, and the imaginary part.

Complex literal syntax

>>-| real part |--+-+--+--| imaginary part |-------------------><
                  '- –-'                       

Real part

|--floating-point constant--------------------------------------|

Imaginary part

|--floating-point constant--*--_Complex_I-----------------------|

_Complex_I is a macro defined in the complex.h header file, representing the imaginary unit i, the square root of -1.

varComplex = 2.0f + 2.0f * _Complex_I;