Question

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

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

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

我正在考虑使用std::int32_t，std::uint32_t，std::int64_t，std::uint64_t等来覆盖safe_product。我相信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位上提高效率？

Answer 1

以完全可移植的方式推导出最快的整数类型并不是一项简单的任务。您可以考虑使用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;
    }
}

为平台上可用的所有整数定义函数

1 个答案: