在C++ 2020之前，没有实现将整数舍入到2的幂，而不使用循环，编译器扩展或移位，假定对类型的宽度有一些限制。有几个关于堆栈溢出的问题。下面的代码显示了一个使用C++ std::countl_zero的解决方案和一个使用GCC的count-leading-zeros内置的替代解决方案，该解决方案适用于unsigned long long以下的任何整数类型。

#include <cmath>

#if 201703L <= __cplusplus
    #include <bit>
    #include <type_traits>
#endif

template <typename T> static constexpr T round_pow2(T v)
{
    /*  Since one is the smallest power of two, all numbers less than or equal
        to one round to one.
    */
    if (v <= 1) return 1;

    /*  For floating-point, the standard frexp function gives us the fraction
        and exponent, and ldexp applies an exponent.  The fraction is scaled to
        [.5, 1), so, if it is less than or equal to .75, we round down.
    */
    if constexpr (std::is_floating_point_v<T>)
    {
        int exponent = 0;
        T fraction = frexp(v, &exponent);
        return ldexp(.5, exponent + (.75 < fraction));
    }

    /*  Here we handle integer types.  The midpoints for rounding to powers of
        two are at 3*2^n.  That is, the transition between rounding to one
        power of two and another occurs at a number that has the form 3*2^n.
        To find which interval v is in, we can divide it by three and then
        find the next lower (instead of nearest) power of two.  To get the
        desired rounding at the midpoint, we use v-1.  So the general algorithm
        is to round (v-1)/3 down to the nearest power of two, then quadruple
        that.  For example:

            v   v-1   (v-1)/3   rounded down   quadrupled
            11   10     3            2             8
            12   11     3            2             8
            13   12     4            4            16

        Note that (v-1)/3 is not quite right for v=2, as the subtraction of 1
        jumps a full power of two, from 2 to 1.  (v-.01)/3 would work, but we
        want to stick with integer arithmetic.

        For the general case, we want 4 * 2**floor(log2((v-1)/3)).  To include
        v=2, we will use 2 * 2**f((v-1)/3), where f(x) is floor(log2(x))+1 but
        clamped to produce at least zero.

        If the C++ 2020 std::countl_zero function is available, we use that.
        Otherwise, we use the GCC builtin __builtin_clzll.  In either case, the
        function returns the number of leading zero bits, which depends on the
        width of the type rather than the operand value alone.  To calculate
        the power of two, we get the bit count for a fixed value (zero or one)
        as a reference point.
    */
    else
    {
        #if __cpp_lib_bitops
            /*  std::countl_zero is only provided for unsigned types, so
                define UT to be the unsigned type corresponding to T.
            */
            using UT  = std::make_unsigned<T>::type;

            return static_cast<UT>(2) << std::countl_zero<UT>(0) - std::countl_zero<UT>((v-1)/3));
        #else
            /*  Since __builtin_clzll is not defined for zero operands, we need
                to ensure its operand is at least 1.  To do this, we change
                (v-1)/3 to (v-1)/3*2+1.  The doubling increases the power of
                two by one, so we change the reference point from zero to one,
                decreasing the number of bits for it by one.
            */
            return 2ull << __builtin_clzll(1) - __builtin_clzll((v-1)/3*2+1);
        #endif
    }
}

浮点使用1位用于符号、n位用于指数和m位用于有效数来编码。例如，32位浮点数被编码为1位用于符号，8位用于指数，23位用于有效数。然后，32位浮点数的值由以下等式简单地给出
值=（-1）^sign * 2^（E-127）（1 + sum from i = 1 to 23（B_（23-1） 2^（-i）））
参见符号here
因此，如果有效数部分< 1.5，则更接近（-1）^sign2^（E-127），如果有效数部分>= 1.5，则更接近（-1）^sign2^（E-126）
有效数部分的第一位表示有效数是否< 1.5 or significand >为1.5（它将2^（-1）= 0.5加到总和上）
因此，您可以简单地查看有效数部分的第一位（在32位情况下为位数22），如果该位为0，则值更接近（-1）^sign2^（E-127），如果该位为1，则值更接近（-1）^sign2^（E-126）