std:: pow, std:: powf, std:: powl

参数

返回值

如果未发生错误，则返回 base 的 exp 次幂（ base exp
）。

如果发生定义域错误，则返回一个由实现定义的值（在支持 NaN 的情况下返回 NaN）。

如果发生极点错误或因溢出导致的范围错误，将返回 ±HUGE_VAL 、 ±HUGE_VALF 或 ±HUGE_VALL 。

如果由于下溢发生范围错误，将返回正确结果（舍入后）。

错误处理

错误报告方式遵循 math_errhandling 中的规范。

如果 base 为有限值且为负数，且 exp 为有限值且非整数，则会发生定义域错误，并可能发生值域错误。

如果 base 和 exp 均为零，则可能出现定义域错误。

如果 base 为零且 exp 为负数，则可能出现定义域错误或极点错误。

如果实现支持 IEEE 浮点算术 (IEC 60559)，

• pow ( + 0 , exp ) ，当 exp 为负奇数时，返回 +∞ 并引发 FE_DIVBYZERO 。
• pow ( - 0 , exp ) ，当 exp 为负奇数时，返回 -∞ 并引发 FE_DIVBYZERO 。
• pow ( ± 0 , exp ) ，当 exp 为负数、有限值，且为偶数或非整数时，返回 +∞ 并引发 FE_DIVBYZERO 。
• pow ( ± 0 , - ∞ ) 返回 +∞ 并可能引发 FE_DIVBYZERO 。
• pow ( + 0 , exp ) ，当 exp 为正奇数时，返回 +0。
• pow ( - 0 , exp ) ，当 exp 为正奇数时，返回 -0。
• pow ( ± 0 , exp ) ，当 exp 为正非整数或正偶数时，返回 +0。
• pow ( - 1 , ±∞ ) 返回 1。
• pow ( + 1 , exp ) 对任意 exp 均返回 1，即使 exp 为 NaN。
• pow ( base, ± 0 ) 对任意 base 均返回 1，即使 base 为 NaN。
• pow ( base, exp ) 当 base 为有限负数且 exp 为有限非整数时，返回 NaN 并引发 FE_INVALID 。
• pow ( base, - ∞ ) 对任意 |base| < 1 返回 +∞。
• pow ( base, - ∞ ) 对任意 |base| > 1 返回 +0。
• pow ( base, + ∞ ) 对任意 |base| < 1 返回 +0。
• pow ( base, + ∞ ) 对任意 |base| > 1 返回 +∞。
• pow ( - ∞, exp ) 当 exp 为负奇数时返回 -0。
• pow ( - ∞, exp ) 当 exp 为负非整数或负偶数时返回 +0。
• pow ( - ∞, exp ) 当 exp 为正奇数时返回 -∞。
• pow ( - ∞, exp ) 当 exp 为正非整数或正偶数时返回 +∞。
• pow ( + ∞, exp ) 对任意负 exp 返回 +0。
• pow ( + ∞, exp ) 对任意正 exp 返回 +∞。
• 除上述指定情况外，若任一参数为 NaN，则返回 NaN。

注释

C++98 在 C 语言 pow() 的基础上添加了 exp 参数类型为 int 的重载版本，且 std :: pow ( float , int ) 的返回类型为 float 。然而 C++11 引入的附加重载规定 std :: pow ( float , int ) 应返回 double 。 LWG 问题 550 针对此冲突提出，解决方案是移除额外的 int 类型 exp 参数重载。

虽然 std::pow 不能用于计算负数的根，但对于指数为 1/3 的常见情况，提供了 std::cbrt 。

额外的重载并不需要完全按照 (A) 的形式提供。它们只需确保对于第一个参数 num1 和第二个参数 num2 满足：

示例

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    // 典型用法
    std::cout << "pow(2, 10) = " << std::pow(2, 10) << '\n'
              << "pow(2, 0.5) = " << std::pow(2, 0.5) << '\n'
              << "pow(-2, -3) = " << std::pow(-2, -3) << '\n';
    // 特殊值
    std::cout << "pow(-1, NAN) = " << std::pow(-1, NAN) << '\n'
              << "pow(+1, NAN) = " << std::pow(+1, NAN) << '\n'
              << "pow(INFINITY, 2) = " << std::pow(INFINITY, 2) << '\n'
              << "pow(INFINITY, -1) = " << std::pow(INFINITY, -1) << '\n';
    // 错误处理
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "pow(-1, 1/3) = " << std::pow(-1, 1.0 / 3) << '\n';
    if (errno == EDOM)
        std::cout << "    errno == EDOM " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "pow(-0, -3) = " << std::pow(-0.0, -3) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

pow(2, 10) = 1024
pow(2, 0.5) = 1.41421
pow(-2, -3) = -0.125
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0
pow(-1, 1/3) = -nan
    errno == EDOM Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised

参见