6

我需要一个pow用于整数的版本。我有 2 个问题需要解决pow：

  1. 如果结果大于我的积分类型，我需要夹紧numeric_limits::max()
  2. 我需要能够处理 41.99999 向上取整到 42，而不是向下取整到 41

C++ 是否在这里为我提供了某种内联解决方案，还是我坚持编写自己的函数：

template <typename T>
enable_if_t<is_integral_v<T>, T> mypow(const T base, unsigned int exp) {
    T result = exp == 0U ? base : 1;

    while(exp-- > 1U) {
        if(numeric_limits<T>::max() / result <= base) return numeric_limits<T>::max();
        result *= base;
    }
    return result;
}
4

2 回答 2

3

C++ 是否在这里为我提供了某种内联解决方案

不，标准库中没有整数pow。

还是我坚持编写自己的函数

是的，您可以编写自己的函数。请注意，您显示的乘法循环可能比std::pow用于实现该函数要慢，特别是因为您在循环中还有一个分支和除法：

template<class I>
I int_pow_no_overflow(I base, I exp)
{
    double max = std::numeric_limits<I>::max();
    double result = std::round(std::pow(base, exp));
    return result >= max
        ? max
        : result;
}

对于更通用的方法，您可能还需要考虑下溢。

还有其他更快的算法（例如Exponentiation by squareing）用于整数求幂而不是您展示的线性算法，但我不确定是否值得考虑它们，除非您处理任意精度算术或嵌入式系统没有浮点单元。

于 2017-06-15T15:28:35.637 回答
2

你的代码没有编译，如果可能的话，你应该先检查你的代码编译，使用你的编译器，或者先在编译器资源管理器上检查它。

此外，您忘记考虑负值。这是整体权力的一个非常重要的特征。下面的代码适用于常规 int 类型。我将让您探索如何将它扩展到其他整数类型。 

#include <type_traits>
#include <iostream>
#include <cmath>
#include <limits>

using namespace std;

template <typename T>
enable_if_t< is_integral<T>::value, T> 
mypow(T base, unsigned int exp) 
{
    T result = T(1);
    bool sign = (base < 0);

    if (sign) base = -base;

    T temp = result;
    while(exp-- != 0) 
    {
        temp *= base;
        if (temp < result)
        {
            return (sign) ? numeric_limits<T>::min() 
                          : numeric_limits<T>::max();
        }
        result = temp;
    }
    return (sign && (exp & 1)) ? -result : result;
}

template <typename T>
enable_if_t< !is_integral<T>::value, int> 
mypow(const T& base, unsigned int exp) 
{
    T result = T(1);
    int i_base = int(floor(base + .5));
    bool sign = (i_base < 0);

    if (sign) i_base = -i_base;

    int temp = result;
    while(exp-- != 0) 
    {
        temp *= i_base;
        if (temp < result)
        {
            return (sign) ? numeric_limits<int>::min() : numeric_limits<int>::max();
        }
        result = temp;
    }
    return (sign && (exp & 1)) ? -result : result;
}

在现实生活中，我会注意地板的使用，即使是在积分情况下。

  template<typename T>
   enable_if_t< is_integral<T>::value, T> 
   mypow(T x, unsigned int y) { return T(floor(pow(x, y) + .5)); }

   template<typename T>
   enable_if_t< !is_integral<T>::value, int> 
   mypow(T x, unsigned int y) { return int(floor(pow(floor(x + .5), y) + .5)); }
于 2017-06-15T15:50:53.147 回答