> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ float The `float` keyword in C++ designates a fundamental data type used to represent single-precision floating-point numbers. It is almost universally implemented according to the IEEE 754 standard for 32-bit base-2 floating-point arithmetic. ## Technical Specifications * **Size:** Typically 4 bytes (32 bits). This can be verified at compile-time using `sizeof(float)`. * **Precision:** Guarantees at least 6 significant decimal digits, safely representing up to 7 digits before rounding errors occur. * **Range:** Approximately $\pm 1.18 \times 10^{-38}$ to $\pm 3.4 \times 10^{38}$. * **Limits:** Hardware-specific boundaries and properties are exposed via the `` header using `std::numeric_limits`. ## Memory Architecture (IEEE 754) A standard 32-bit `float` is divided into three contiguous bit fields: 1. **Sign bit (1 bit):** Determines if the number is positive (`0`) or negative (`1`). 2. **Exponent (8 bits):** Stores the exponent offset by a bias of 127. 3. **Mantissa / Significand (23 bits):** Stores the fractional part of the number. ## Syntax and Initialization By default, floating-point literals in C++ are parsed as `double` (double-precision, 64-bit). To explicitly declare a `float` literal, you must append the `f` or `F` suffix. Omitting the suffix results in an implicit narrowing conversion from `double` to `float`. This conversion undergoes rounding (typically round-to-nearest-ties-to-even) to fit the lower precision type. ```cpp theme={"dark"} // Standard initialization with the 'f' suffix float a = 3.14f; float b = -0.005F; // Scientific notation float c = 6.022e23f; // 6.022 * 10^23 float d = 1.6e-19f; // 1.6 * 10^-19 // Uniform (brace) initialization (prevents narrowing conversions) float e { 2.718f }; // Omitting the suffix causes a double-to-float narrowing conversion float f = 3.14; // Warning: implicit conversion from 'double' to 'float' ``` ## Safe Comparison Due to the inherent precision limits and rounding errors of floating-point arithmetic, using the standard equality operator (`==`) to compare `float` values is highly discouraged. Using `std::numeric_limits::epsilon()` as an absolute tolerance is a common anti-pattern. Machine epsilon represents the difference between `1.0` and the next representable value. For numbers significantly larger than `1.0`, the gap between representable floats is much larger than epsilon, meaning an absolute check will incorrectly evaluate to `false` even for adjacent floating-point values. Instead, comparisons should use a relative tolerance scaled to the magnitude of the operands, or a fixed tolerance appropriate for the specific mathematical domain. ```cpp theme={"dark"} #include #include float x = 0.1f + 0.6f; float y = 0.7f; // Unsafe: Evaluates to false due to mantissa rounding errors bool is_equal_unsafe = (x == y); // Safe: Relative epsilon comparison // Scales the allowed error margin based on the magnitude of the operands float tolerance = 1e-5f; // Context-appropriate base tolerance float max_val = std::max({1.0f, std::abs(x), std::abs(y)}); bool is_equal_safe = std::abs(x - y) <= tolerance * max_val; ``` ## Special Values The IEEE 754 standard defines specific bit patterns for non-numeric or boundary values, which are fully supported by the C++ `float` type: * **Infinity (`INF` / `-INF`):** Occurs on overflow or division by zero. * **Not a Number (`NaN`):** Represents undefined mathematical operations (e.g., `0.0f / 0.0f`). * **Signed Zero (`+0.0f` and `-0.0f`):** Evaluated as equal (`+0.0f == -0.0f`), but behave differently in certain mathematical limits (like `1.0f / -0.0f`). ```cpp theme={"dark"} #include #include // Generating special values float pos_inf = std::numeric_limits::infinity(); float neg_inf = -std::numeric_limits::infinity(); float not_a_num = std::numeric_limits::quiet_NaN(); // Validating special values bool is_nan = std::isnan(not_a_num); // Returns true bool is_inf = std::isinf(pos_inf); // Returns true ``` ## Type Promotion and Casting When a `float` is used in a binary arithmetic operation with a `double`, the `float` undergoes standard arithmetic conversion (promotion) to `double` before the operation executes. To explicitly convert other types to `float`, `static_cast` should be used. ```cpp theme={"dark"} int x = 10; double y = 5.5; // Explicit cast from int to float float z = static_cast(x); // 'a' is promoted to double for the addition. // The resulting double is then implicitly narrowed and rounded back to float. float a = 2.0f; float result = a + y; ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More