我想为签名为 INT 的不同整数类型编写一系列函数

INT safe_product(INT a, INT b, bool& error);

它接受两个整数 a 和 b，如果 a * b 没有溢出则返回 a * b，如果 a * b 溢出则返回 0 并将错误设置为真。我也希望这个功能高效，我希望它在 32 位和 64 位平台上运行。

我正在考虑使用 std::int32_t、std::uint32_t、std::int64_t、std 重载 safe_product::uint64_t 等。我相信 std::int64_t 并不总是用 32 位编译器定义的。有没有办法在编译时知道它是否被定义？

此外，如果我们在 64 位平台上，在 2 个 32 位整数之间实现安全乘积的最佳方法如下:

std::int32_t safe_product(std::int32_t a, std::int32_t b,
                          bool& error) {
  const std::int64_t a_64 = a;
  const std::int64_t b_64 = b;
  const std::int64_t ab_64 = a_64 * b_64;
  if (ab_64 > std::numeric_limits<std::int32_t>::max() ||
      ab_64 < std::numeric_limits<std::int32_t>::min()) {
    error = true;
    return 0;
  } else {
    error = false;
    return static_cast<std::int32_t>(ab_64);
  }
}

但如果我们是 32 位平台，最快的算法可能意味着计算一些整数除法。

所以我有两个问题:

• 我如何声明我的 safe_product，以便为我的平台上可用的所有整数类型定义它(显然不是为那些不存在的整数类型)？

• 如何使用我知道的算法使其在 32 位和 64 位上都高效？

最佳答案

以完全可移植的方式推导出最快的整数类型并不是一项简单的任务。您可能会考虑使用 int_fastXX_t 系列类型，但不能保证它们就是您想要的。您还可以查看 void* 的大小，并引入您自己的逻辑来推导您要使用的整数类型。为简单起见，我将 int 和 unsigned int 定义为最快的整数。

首先，定义我们的“最快”整数类型和一个辅助特征，以了解类型是否小到可以提升。正如您在示例中所做的那样，任何更小的东西都会被提升为“最快”的整数类型。任何大小相等或更大的东西都将使用整数除法来预测溢出。

#include <cstdint>
#include <limits>
#include <type_traits>

// Define the fastest types for our case
using t_fast_int = int;
using t_fast_uint = unsigned int;

// Helper trait, to indicate if a type is small enough to promote
template<class T>
struct t_is_small : std::bool_constant<sizeof(T) < sizeof(t_fast_int)> {};

其次，定义一个泛型函数并使用enable_if ([link( http://en.cppreference.com/w/cpp/types/enable_if )) 只为小类型启用它。这使用您在问题中描述的方法。

template<class T>
std::enable_if_t<t_is_small<T>::value, T>
safe_product(T a, T b, bool& error)
{
    // Should we use intmax_t or uintmax_t in this case?
    using t_large = std::conditional_t<std::is_signed<T>::value, t_fast_int, t_fast_uint>;

    const t_large a_64 = a;
    const t_large b_64 = b;
    const t_large ab_64 = a_64 * b_64;
    if (ab_64 > std::numeric_limits<T>::max() ||
        ab_64 < std::numeric_limits<T>::min())
    {
        error = true;
        return 0;
    }
    else
    {
        error = false;
        return static_cast<T>(ab_64);
    }
}

最后，为大整数类型添加另一个重载。请注意，enable_if 条件已反转。我使用整数除法来预测上溢或下溢。

template<class T>
std::enable_if_t<t_is_small<T>::value == false, T>
safe_product(T a, T b, bool& error)
{
    if(b == 0) {
        // The result will be zero (avoids division by zero below)
        error = false;
    }
    else {
        // Calculate the largest `a` that would not result in an overflow
        constexpr auto max_int = std::numeric_limits<T>::max();
        auto max_a = max_int / b;

        // Calculate the smallest `a` that would not result in underflow
        constexpr auto min_int = std::numeric_limits<T>::min();
        auto min_a = min_int / b;

        // If a is greater than max_a an overflow would occur
        // If a is less than min_a an undeflow would occur
        if(b > 0) {
            error = (a > max_a) || (a < min_a);
        }
        else {
            error = (a < max_a) || (a > min_a);
        }
    }
    if(error) {
        return 0;
    }
    else {
        return a * b;
    }
}

关于c++ - 为平台上可用的所有整数定义一个函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41891582/