在C ++中用下限，ceil和向外舍入模式除整数

如何解决在C ++中用下限，ceil和向外舍入模式除整数

最近，我看到this question询问如何使用 ceil 舍入（朝正无穷大）舍入整数。不幸的是，答案要么不适用于带符号整数，要么存在下溢和上溢问题。

例如，accepted answer具有以下解决方案：

q = 1 + ((x - 1) / y);

x为零时，~0出现下溢，结果不正确。

如何正确地对有符号和无符号整数进行 ceil 舍入，以及如何实现 floor （向负无穷大）和 outwards （远离零）？

解决方法

在C ++中，/除法运算默认使用 truncate （向零）舍入。我们可以将除法结果调整为零以实现其他舍入模式。请注意，当除法没有余数时，所有舍入模式都是等效的，因为不需要舍入。

考虑到这一点，我们可以实现不同的舍入模式。但是在开始之前，我们将需要一个用于返回类型的帮助程序模板，以便我们不会在所有地方都使用auto返回类型：

#include <type_traits>

/**
 * Similar to std::common_type_t<A,B>,but if A or B are signed,the result will also be signed.
 *
 * This differs from the regular type promotion rules,where signed types are promoted to unsigned types.
 */
template <typename A,typename B>
using common_signed_t =
    std::conditional_t<std::is_unsigned_v<A> && std::is_unsigned_v<B>,std::common_type_t<A,std::common_type_t<std::make_signed_t<A>,std::make_signed_t<B>>>;

天花板（朝+∞）

对于负商，

Ceil 舍入与 truncate 舍入相同，但是对于正商和非零余数，我们将舍入为零。这意味着我们增加了非零余数的商。

由于if-constexpr，我们可以仅使用一个函数来实现所有功能：

template <typename Dividend,typename Divisor>
constexpr common_signed_t<Dividend,Divisor> div_ceil(Dividend x,Divisor y)
{
    if constexpr (std::is_unsigned_v<Dividend> && std::is_unsigned_v<Divisor>) {
        // quotient is always positive
        return x / y + (x % y != 0);  // uint / uint
    }
    else if constexpr (std::is_signed_v<Dividend> && std::is_unsigned_v<Divisor>) {
        auto sy = static_cast<std::make_signed_t<Divisor>>(y);
        bool quotientPositive = x >= 0;
        return x / sy + (x % sy != 0 && quotientPositive);  // int / uint
    }
    else if constexpr (std::is_unsigned_v<Dividend> && std::is_signed_v<Divisor>) {
        auto sx = static_cast<std::make_signed_t<Dividend>>(x);
        bool quotientPositive = y >= 0;
        return sx / y + (sx % y != 0 && quotientPositive);  // uint / int
    }
    else {
        bool quotientPositive = (y >= 0) == (x >= 0);
        return x / y + (x % y != 0 && quotientPositive);  // int / int
    }
}

乍一看，有符号类型的实现似乎很昂贵，因为它们同时使用整数除法和模除法。但是，在现代体系结构上，部门通常会设置一个标志来指示是否存在剩余物，因此x % y != 0在这种情况下是完全空闲的。

您可能还想知道为什么我们不先计算商，然后再检查商是否为正。这是行不通的，因为我们已经在该划分期间失去了精度，因此我们以后无法执行此测试。例如：

-1 / 2 = -0.5
// C++ already rounds towards zero
-0.5 -> 0
// Now we think that the quotient is positive,even though it is negative.
// So we mistakenly round up again:
0 -> 1

地板（朝-∞方向）

对于正商，

底数舍入与 truncate 相同，但是对于负商，我们舍入为零。这意味着我们递减了非零余数的商。

template <typename Dividend,Divisor> div_floor(Dividend x,Divisor y)
{
    if constexpr (std::is_unsigned_v<Dividend> && std::is_unsigned_v<Divisor>) {
        // quotient is never negative
        return x / y;  // uint / uint
    }
    else if constexpr (std::is_signed_v<Dividend> && std::is_unsigned_v<Divisor>) {
        auto sy = static_cast<std::make_signed_t<Divisor>>(y);
        bool quotientNegative = x < 0;
        return x / sy - (x % sy != 0 && quotientNegative);  // int / uint
    }
    else if constexpr (std::is_unsigned_v<Dividend> && std::is_signed_v<Divisor>) {
        auto sx = static_cast<std::make_signed_t<Dividend>>(x);
        bool quotientNegative = y < 0;
        return sx / y - (sx % y != 0 && quotientNegative);  // uint / int
    }
    else {
        bool quotientNegative = (y < 0) != (x < 0);
        return x / y - (x % y != 0 && quotientNegative);  // int / int
    }
}

实现几乎与div_ceil相同。

远离零

远离零与 truncate 完全相反。基本上，我们需要根据商的符号递增或递减，但前提是存在余数。这可以表示为将商的sgn添加到结果中：

template <typename Int>
constexpr signed char sgn(Int n)
{
    return (n > Int{0}) - (n < Int{0});
};

使用此辅助函数，我们可以完全实现 up 舍入：

template <typename Dividend,Divisor> div_up(Dividend x,Divisor y)
{
    if constexpr (std::is_unsigned_v<Dividend> && std::is_unsigned_v<Divisor>) {
        // sgn is always 1
        return x / y + (x % y != 0);  // uint / uint
    }
    else if constexpr (std::is_signed_v<Dividend> && std::is_unsigned_v<Divisor>) {
        auto sy = static_cast<std::make_signed_t<Divisor>>(y);
        signed char quotientSgn = sgn(x);
        return x / sy + (x % sy != 0) * quotientSgn;  // int / uint
    }
    else if constexpr (std::is_unsigned_v<Dividend> && std::is_signed_v<Divisor>) {
        auto sx = static_cast<std::make_signed_t<Dividend>>(x);
        signed char quotientSgn = sgn(y);
        return sx / y + (sx % y != 0) * quotientSgn;  // uint / int
    }
    else {
        signed char quotientSgn = sgn(x) * sgn(y);
        return x / y + (x % y != 0) * quotientSgn;  // int / int
    }
}

未解决的问题

不幸的是，这些功能不适用于所有可能的输入，这是我们无法解决的问题。例如，将uint32_t{3 billion} / int32_t{1}除以得到int32_t(3 billion)，这是使用32位带符号整数无法表示的。在这种情况下，我们会产生下溢。

使用较大的返回类型将是64位整数以外的所有选项，因为64位整数没有更大的选择。因此，用户有责任确保在他们将未签名的数字传递给该函数时，它等同于其签名表示。