天道酬勤,学无止境

为什么 cmath pow 给出的答案不准确?(Why does cmath pow give inaccurate answers?)

问题

在 C++11 中:

pow(1061,6);   // = 1426567426713180416

检查最后 3 位数字。 我确定结果是错误的,因为 1061^6 = 1426567426713180361。

但是这种另一种方法是正确的:

long a =1;    
for(int i=0; i<6 ; i++){ a*=1061; }
cout << a;  // = 1426567426713180361

pow 包含在 cmath 中。

如果有人知道,我想知道为什么两个结果不相等。

回答1

pow使用double作为其输出,其精度约为 16 位十进制数字。 一个 64 位的long却有 19 个。

回答2

std::pow 将为积分情况返回 double ,这里的答案解释了第一个积分,其中 double 不能再准确地表示每个积分从9007199254740993开始,此后我们可能有整数不能完全表示为 double 。

我们可以更容易地看到这一点,因为使用统一初始化的窄化转换是非良构的。 使用您想要的结果,我们看到:

double d2{1426567426713180361};

是一个缩小转换(live godbolt)

error: constant expression evaluates to 9007199254740993 which cannot be narrowed to type 'double' [-Wc++11-narrowing]
double d1{9007199254740993} ;
        ^~~~~~~~~~~~~~~~

因为它不能准确表示。 我们还可以看到前面的数字也是一个缩小的转换:

double d1{9007199254740993} ;

尽管:

double d3{1426567426713180416};

不是。

回答3

std::pow适用于double s。 对于如此大的整数值,它并没有像整数算术那样保持结果数的精度。

标签

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 为什么我的std :: pow整数运算给出错误的答案?(Why is my integer math with std::pow giving the wrong answer?)
    问题 考虑以下代码: #include <iostream> #include <cmath> int main() { int i = 23; int j = 1; int base = 10; int k = 2; i += j * pow(base, k); std::cout << i << std::endl; } 输出“ 122”而不是“ 123”。 它是g ++ 4.7.2(MinGW,Windows XP)中的错误吗? 回答1 std :: pow()适用于浮点数,浮点数没有无限的精度,可能您正在使用的标准库的实现以(较差的)方式实现pow() ,这使得缺乏无限的精度变得很重要。 但是,您可以轻松定义自己的与整数一起使用的版本。 在C ++ 11中,您甚至可以将其设置为constexpr (以便可以在编译时计算结果): constexpr int int_pow(int b, int e) { return (e == 0) ? 1 : b * int_pow(b, e - 1); } 这是一个实时示例。 尾递归形式(Dan Nissenbaum提供): constexpr int int_pow(int b, int e, int res = 1) { return (e == 0) ? res : int_pow(b, e - 1, b * res); }
  • Why does cmath pow give inaccurate answers?
    In C++11: pow(1061,6); // = 1426567426713180416 Check the last 3 digits. I know for sure that result is wrong, because 1061^6 = 1426567426713180361. But this other method does it right: long a =1; for(int i=0; i<6 ; i++){ a*=1061; } cout << a; // = 1426567426713180361 pow is included from cmath. If anyone knows, I'd like to know why both results aren't equal.
  • cmath 中 sqrt、sin、cos、pow 等的定义(Definitions of sqrt, sin, cos, pow etc. in cmath)
    问题 是否有可用的函数定义,如sqrt() 、 sin() 、 cos() 、 tan() 、 log() 、 exp() (这些来自 math.h/cmath)? 我只是想知道它们是如何工作的。 回答1 这是一个有趣的问题,但是除非您碰巧知道所使用的方法,否则阅读高效库的来源不会让您走得很远。 这里有一些提示可以帮助您理解经典方法。 我的信息绝不准确。 以下方法仅为经典方法,具体实现可使用其他方法。 经常使用查找表三角函数通常通过 CORDIC 算法实现(在 CPU 上或使用库)。 请注意,通常正弦和余弦是一起计算的,我一直想知道为什么标准 C 库不提供sincos函数。 平方根使用牛顿法和一些巧妙的实现技巧:您可能会在网络上的某个地方找到 Quake 源代码的摘录,其中包含令人难以置信的 1 / sqrt(x) 实现。 指数和对数使用 exp(2^nx) = exp(x)^(2^n) 和 log2(2^nx) = n + log2(x) 使参数接近零(对数为 1)并使用有理函数近似(通常是 Padé 近似)。 请注意,这个完全相同的技巧可以让您获得矩阵指数和对数。 根据@Stephen Canon 的说法,现代实现更喜欢泰勒展开而不是有理函数近似,其中除法比乘法慢得多。 其他函数可以从这些函数中推导出来。 实现可以提供专门的例程。 pow(x, y) = exp(y * log
  • 函数 pow 是如何工作的?(How does the function pow work?)
    问题 编译以下程序后,我得到输出“2346”,但期待“2345”。 #include<math.h> #include<iostream.h> int nr_cif(int a) { int k=0; while(a!=0) { a = a/10; k++; } return k; } void Nr(int &a){ int k = nr_cif(a); a = a % (int)pow(10,k-1); } int main() { int a = 12345; Nr(a); cout<<a; } 调试后,我注意到它在评估后出错:a = a % (int)pow(10,k-1)。 为什么会在这里断呢? 回答1 将pow用于整数数学并不是一个好主意。 我将更改代码如下: void Nr(int &a) { int ten_k = 1; while (ten_k < a) ten_k *= 10; a %= ten_k/10; // 10-to-the-(k-1) } 您的代码中没有任何内容需要小数位数,只有位置值。 因此,将位置值设为您的变量。 (您也可以使用原始的 while 循环,这对于负输入效果更好。但计算并返回 10 的 k 次幂,而不是 k)。 pow的问题在于它适用于浮点值,并给出非常接近但不准确的结果。 该错误可能足以导致舍入值(转换为int )出错。
  • 标准对像 std::pow、std::log 等 cmath 函数有什么看法?(What does standard say about cmath functions like std::pow, std::log etc?)
    问题 标准是否保证函数在所有实现中返回完全相同的结果? 以 32 位 IEEE 浮点数的pow(float,float)为例。 如果传入相同的两个浮点数,所有实现的结果是否相同? 或者,根据用于实现pow的算法,标准是否允许在微小差异方面具有一定的灵活性? 回答1 不,C++ 标准不要求 cmath 函数的结果在所有实现中都相同。 对于初学者,您可能无法获得 IEEE-754/IEC 60559 浮点运算。 也就是说,如果一个实现确实使用 IEC 60559 并定义了__STDC_IEC_559__ ,那么它必须遵守 C 标准的附件 F(是的,你的问题是关于 C++,但 C++ 标准遵循 C 标准,如math.h )。 附件 F 指出: float类型与 IEC 60559 单一格式相匹配。 double类型与 IEC 60559 double 格式匹配。 long double类型匹配 IEC 60559 扩展格式,否则匹配非 IEC 60559 扩展格式,否则匹配 IEC 60559 double格式。 此外,它说正常的算术必须遵循 IEC 60559 标准: + 、 − 、 *和/运算符提供 IEC 60559 加、减、乘和除运算。 它还要求sqrt遵循 IEC 60559: <math.h>的sqrt函数提供 IEC 60559 平方根运算。
  • 使用分治法找到数字的第n个根(finding nth root of a number by using divide and conquer method)
    问题 我需要有关如何获得某个数字的第n个根的帮助。 用户输入数字n和要作为其根的数字。 我需要在没有cmath lib的情况下使用分而治之的方法来解决此问题。 这是我的尚不可用的代码: #include<iostream> using namespace std; float pow(float a,float c){ if (a == 0) return 0; else if(a == 1) return 1; else{ float p = pow(a,(c/2)); if(c%2) return p*p*a; else return p*p; } } int main(){ float a,b; float c; cout << "Enter positive number:(base)" << endl; do{ cin >> a; }while (a < 0); cout << "Enter number: (root)" << endl; cin >> b; c = 1/b; cout << "Result:"<<pow(a,c) << endl; system("pause"); return 0; } 关于如何解决此问题的任何想法都将是无用的。 回答1 让我告诉您如何使用分治法来求平方根。 第n个根将是相似的。 对于给定的x ,您需要搜索0到x之间的平方根。
  • 奇怪的战俘(x,y); 行为(Strange pow(x, y); behaviour)
    问题 在做作业的时候,我注意到一些非常奇怪的东西,我只是弄不明白为什么。 int x = 5; cout << pow(x, 2); 结果是25。很好。 但是,如果我像这样编写相同的程序: int x = 5; int y = pow(x, 2); cout << y; 结果是24! 当x为2、3、4、6、7、8时没问题,但是当有5、10、11、13等时,结果比应有的值低1。 与if()相同。 for (int x = 1; x <= 20 ; x++) { if (x * x == pow(x, 2)) cout << x << endl; } 它打印出数字1、2、3、4、6、8、12、16。 回答1 std :: pow()返回浮点数。 例如,如果结果为24.99999999并将其24.99999999为int ,则将其截断为24 。 这就是您在第二个代码示例中所做的。 在第一个代码示例中, cout不会转换为int并输出正确的结果。 回答2 'pow'返回一个双精度值,而不是整数。 当将double值转换为int值时,其值将被截断。 http://www.cplusplus.com/reference/cmath/pow/ 不建议将double与int比较。 http://www.cplusplus.com/reference/cmath/pow/
  • python上负数的三次根(Cubic root of the negative number on python)
    问题 有人可以帮我找到有关如何使用python计算负数的立方根的解决方案吗? >>> math.pow(-3, float(1)/3) nan 这是行不通的。 负数的三次根是负数。 有什么办法吗? 回答1 您可以使用: -math.pow(3, float(1)/3) 或更笼统地说: if x > 0: return math.pow(x, float(1)/3) elif x < 0: return -math.pow(abs(x), float(1)/3) else: return 0 回答2 只需简单地使用De Moivre公式,就足以表明一个值的立方根(无论是否为符号)都是多值函数。 这意味着,对于任何输入值,将有三种解决方案。 目前提供的大多数解决方案仅返回原理根。 下面显示了一个返回所有有效根并显式测试非复杂特殊情况的解决方案。 import numpy import math def cuberoot( z ): z = complex(z) x = z.real y = z.imag mag = abs(z) arg = math.atan2(y,x) return [ mag**(1./3) * numpy.exp( 1j*(arg+2*n*math.pi)/3 ) for n in range(1,4) ] 编辑:根据要求,在不适当依赖numpy的情况下
  • 在 C++ 中定义运算符 **(Define operator ** in C++)
    问题 我如何定义运算符**以便它可以执行 2 个数字的幂运算。 例如2 ** 3 。 它应该给出答案为 8。 或者间接有什么方法可以用运算符重载而不是#define宏来做到这一点? 回答1 你不能。 您只能重载现有的运算符,而不能重载内置类型。 回答2 你不能。 你只能在 C++ 中重载现有的运算符; 您不能添加新操作符,也不能更改现有操作符的元数或结合性。 甚至预处理器在这里也无能为力——它的标识符不能是符号。 回答3 如果您愿意在**上做出妥协并想混淆您的代码: #include <cmath> #include <iostream> struct foo { foo(int i) : i_(i) {} int operator*(int exp) { return std::pow(i_,exp); } private: int i_; }; struct bar { } power_of; foo operator*(int i, bar) { return foo{i}; } int main() { std::cout << 2 *power_of* 3; // prints 8 } 否则,只需使用std::pow 。 回答4 就像提到的其他答案一样,这对于内置类型是不可能的,但是你可以让它适用于像这样的自定义类型(最小代码示例): #include <cmath>
  • 如何在不包含 cmath 库的情况下使用 pow(How is it possible to use pow without including cmath library)
    问题 我正在尝试学习 C++,我正在使用 MS Visual Studio 2019。我有以下代码: #include <iostream> int main() { std::cout << pow(10, 2); } 如何在不包含cmath情况下编译和运行而不会出错? 在解决方案中,只有一个包含上述代码的文件。 回答1 如何在 C++ 中使用 pow 而不包含 cmath 库 通过包含另一个包含<math.h>标头的标头。 不能保证标准库头文件一般不会包含其他头文件,也不能保证<iostream>不会特别包含<cmath> 。 也不能保证<iostream>将包含该头文件,因此当使用另一个标准库实现或相同版本的另一个版本时,该程序可能无法编译。 总而言之:永远不要依赖这种传递包含。 始终直接包含您所依赖的声明的所有标头,除非显式包含传递包含(例如, <ios>保证包含<iosfwd> )。 您不能使用成功的编译来证明您提供了所有必需的直接包含。 回答2 更新:关注@Pete Becker 的评论,我更正了我的回答: 您的代码格式不正确,因此调用了所谓的未定义行为而不是实现定义的行为。 然而,这个结论并不完全安全,因为我们在这里进入语言律师的部分。 未定义行为 (UB) 定义为 本国际标准没有强加任何要求的行为,这通常意味着:不要试图推理这个代码,也不要使用它。 问题是,C++
  • std::pow 给出了分数指数的错误近似值(std::pow gives a wrong approximation for fractional exponents)
    问题 这就是我想要做的 double x=1.1402 double pow=1/3; std::pow(x,pow) -1; 结果是 0 但我希望是 0.4465 等式是(1 + x) ^3= 1.1402 ,找到x 。 回答1 1/3是作为整数算术完成的,因此您将 0 分配给pow 。 试试pow(x, 1.0/3.0); 回答2 1/3 是 0。那是整数除法。 尝试: double pow = 1.0 / 3.0; 为了: #include <iostream> #include <cmath> int main(void) { double x = 1.1402; double pow = 1.0/3.0; std::cout << std::pow(x, pow) - 1; } 回答3 许多人说 1/3 = 0,但没有解释为什么会这样。 C 和 C++ 将根据操作数的类型执行操作。 由于两个操作数都是整数,因此它执行整数除法以创建整数结果。 当强制将该整数结果分配给双精度变量时,它将整数 0 转换为双精度 0.0。 没有必要将两个操作数都设为双精度,如果其中一个是双精度,编译器会在执行操作之前将另一个也转换为双精度。 1.0/3 或 1/3.0 都将返回您预期的结果,1.0/3.0 也是如此。 回答4 你的 1/3 是整数除法,整数除法的结果是 0。
  • **(1/2), math.sqrt 和 cmath.sqrt 之间的区别?(Difference between **(1/2), math.sqrt and cmath.sqrt?)
    问题 x**(1/2) 、 math.sqrt()和cmath.sqrt()之间有什么区别? 为什么cmath.sqrt()单独得到二次方的复根? 我应该专门将它用于平方根吗? 他们在后台做什么不同? 回答1 如果分别查看 cmath 和 math 的文档,您会发现: cmath“提供对复数数学函数的访问” math “函数不能与复数一起使用;如果您需要支持复数,请使用 cmath 模块中的同名函数。” (**)运算符映射到pow函数,重要的区别是pow将其参数转换为浮点数。 因此,对于相同的参数,您可能会看到三个函数的不同结果,如下所示。 请注意,如果表达式有一个真正的解决方案,将有返回的值之间没有差异math.sqrt和返回值的实部cmath.sqrt 。 但是,如果没有真正的解决方案可用,您将收到math.sqrt错误。 编辑:正如@jermenkoo 指出的那样,由于/运算符的工作方式不同,Python 2 和 3 之间(**)返回的值会有所不同。 但是,如果您直接使用 0.5 而不是 1/2,那应该不会导致问题。 回答2 ** .5 和 math.sqrt 将几乎相同。 ** .5 将从标准 C 库 powhttps://hg.python.org/cpython/file/661195a92131/Objects/floatobject.c#l783 派你到 pow
  • 如何提升[重复]的力量(How to raise to the power of [duplicate])
    问题 这个问题在这里已经有了答案: 为什么 10^1 是 11? (6 个回答) 7年前关闭。 我对 C 很陌生 我试图将某事赋予某事的力量 例如。 5^3=125; 但是当我编码时 #include <math.h> ... printf("%d", 5^3); 我得到 6. 我在做一些根本错误的事情吗? 回答1 ^是 C 中的按位异或运算符。 5是二进制表示的101 , 3是011 。 所以101 XOR 011 = 110 ,这是十进制的6 。 你想要的是pow(5,3) (像你一样包含math.h后可用)。 但是请注意,它作用于双精度数而不是整数,因此您的返回值将是浮点数,通常不准确。 如果您需要精确的整数取幂,那么您必须使用额外的库或实现您自己的幂函数。 这并不难,因为算法可以通过平方来查看求幂。 标准 C 不包括整数取幂函数。 无论如何,对于整数取幂,重要的是要处理溢出,这对于小输入值可能已经发生。 同样要打印返回的双精度值,您必须将双printf("%d", (int)pow(5,3))转换为 int printf("%d", (int)pow(5,3))或将其打印为浮点printf("%f", pow(5,3)) 回答2 ^是 C 中的 XOR 运算符。 相反,您应该使用math.h的pow函数,但是pow返回 double #include <math.h>
  • c ++中整数的幂(power of an integer in c++ [duplicate])
    问题 这个问题已经在这里有了答案: 实现基于整数的幂函数pow(int,int)的最有效方法(17个答案) 5年前关闭。 我需要从pow(a,b)中获取一个整数(a和b都是整数)。 当前包含(int) pow( (double)a, (double)b)是错误的。 也许有人可以帮助使用pow(a,b)使用整数并返回整数的函数吗? 但这是一个奇怪的部分:我使用Geany(和g ++ / gcc编译器)在Linux中编写了脚本,并且仅将脚本pow(a,b)编译并可以正常工作。 但是在大学里,我有Dev-C ++(和MS Windows)。 在Dev-C ++中,脚本编译时未出现错误[Warning] converting to从double' [Warning] converting to int double' 我也需要使该脚本在Windows(和Mingw编译器)下工作。 回答1 您可以炫耀一种不错的递归方法: int myPow(int x, int p) { if (p == 0) return 1; if (p == 1) return x; return x * myPow(x, p-1); } 回答2 比Zed更好的递归方法。 int myPow(int x, unsigned int p) { if (p == 0) return 1; if (p == 1)
  • GCC C ++战俘精度(GCC C++ pow accuracy)
    问题 因此,我参加了一次计算机竞赛,并且发现了一个奇怪的错误。 pow(26,2)总是返回675,有时是674? 即使正确答案是676。pow(26,3),pow(26,4)等也会出现此类错误。在比赛后进行一些调试后,我相信答案与int向下取整有关。 有趣的是,我从未发生过这种错误。 我曾经在Windows 8上运行mingw的计算机。GCC版本相当新,我相信大约2-3个月大。 但是我发现的是,如果我对此类错误打开o1 / o2 / o3优化标记,则会奇迹般地消失。 pow(26,2)总是会得到676 aka正确答案有人能解释为什么吗? #include <cmath> #include <iostream> using namespace std; int main() { cout<<pow(26,2)<<endl; cout<<int(pow(26,2))<<endl; } 双打的结果很奇怪。 double a=26; double b=2; cout<<int(pow(a,b))<<endl; #outputs 675 cout<<int(pow(26.0,2.0))<<endl; # outputs 676 cout<<int(pow(26*1.00,2*1.00))<<endl; # outputs 676 回答1 函数pow对两个浮点值进行运算
  • C/C++ 中 pow() 函数的快速实现/逼近(Fast implementation/approximation of pow() function in C/C++)
    问题 我正在寻找更快的实现或cmath提供的函数的近似值。 我需要加速以下功能 pow(x,y) exp(z*pow(x,y)) 其中z<0 。 x来自 (-1.0,1.0) y来自 (0.0, 5.0) 回答1 以下是一些近似值: 针对 Java 和 C/C++ 的优化 pow 近似。 这个近似是非常不准确的,如果它足够好,你必须自己尝试。 优化的 Java 指数函数。 相当不错! 我将它用于神经网络。 如果上述 pow 近似值不够好,您仍然可以尝试用指数函数替换它,这取决于您的机器和编译器,这可能会更快: x^y = e^(y*ln(x))结果: e^(z * x^y) = e^(z * e^(y*ln(x))) 另一个技巧是当公式的某些参数不经常更改时。 因此,如果例如 x 和 y 大部分是常数,您可以预先计算 x^y 并重用它。 回答2 x 和 y 的可能值是多少? 如果它们在合理范围内,构建一些查找表可能会有所帮助。 回答3 我推荐 Jack W. Crenshaw 所著的“Math Toolkit for Real-Time Programming”一书中的例程。 您可能还想发布一些代码来展示您如何调用这些函数,因为可能还有一些其他更高级别的优化可能性,这些可能性从目前给出的描述中并不明显。
  • 在C ++中用^计算指数时,为什么不能得到正确的结果?(Why am I not getting correct result when I calculate exponent with ^ in C++?)
    问题 我正在使用Bode的formuala来计算第n个行星与太阳的距离 dist = (4 + 3*(2^(n-2)))/10 如果以这种方式计算距离,我将获得正确的值: dist[2] = ((4 + 3*1)/10.0) ; dist[3] = ((4 + 3*2)/10.0) ; dist[4] = ((4 + 3*4)/10.0) ; 但是这样做,给了我不正确的值: vector <double> dist(5); for (unsigned int i = 2; i < 5; i++) { dist[i] = ((4 + 3*(2^(3-2)))/10.0) ; } 为什么这样? 回答1 ^字符表示按位异或,而不是您期望的指数函数。 由于已经在循环中进行了计算,因此您可以轻松生成等式中所需的2的幂,因此简单的事情(与您的代码接近)将是: vector<double> dist(5); unsigned int j = 1; for(unsigned int i = 2; i < 5; i++){ dist[i] = (4+3*j)/10.0; j = j * 2; } 在此特定实例中,我们将j初始化为所需的第n-2值,然后将其乘以2得到所需的下一个2的幂。 回答2 因为^不是C ++中的幂运算符。 您可以使用std::pow但可以使用double
  • 有与没有额外变量的奇怪浮点行为,为什么?(Bizarre floating-point behavior with vs. without extra variables, why?)
    问题 当我在 VC++ 2013(32 位,无优化)中运行以下代码时: #include <cmath> #include <iostream> #include <limits> double mulpow10(double const value, int const pow10) { static double const table[] = { 1E+000, 1E+001, 1E+002, 1E+003, 1E+004, 1E+005, 1E+006, 1E+007, 1E+008, 1E+009, 1E+010, 1E+011, 1E+012, 1E+013, 1E+014, 1E+015, 1E+016, 1E+017, 1E+018, 1E+019, }; return pow10 < 0 ? value / table[-pow10] : value * table[+pow10]; } int main(void) { double d = 9710908999.008999; int j_max = std::numeric_limits<double>::max_digits10; while (j_max > 0 && ( static_cast<double>( static_cast<unsigned long long>( mulpow10(d, j
  • 查找平方根而不使用sqrt函数?(Finding square root without using sqrt function?)
    问题 我正在寻找无需使用sqrt函数即可找出平方根的算法,然后尝试进行编程。 我最终在C ++中获得了这个工作代码 #include <iostream> using namespace std; double SqrtNumber(double num) { double lower_bound=0; double upper_bound=num; double temp=0; /* ek edited this line */ int nCount = 50; while(nCount != 0) { temp=(lower_bound+upper_bound)/2; if(temp*temp==num) { return temp; } else if(temp*temp > num) { upper_bound = temp; } else { lower_bound = temp; } nCount--; } return temp; } int main() { double num; cout<<"Enter the number\n"; cin>>num; if(num < 0) { cout<<"Error: Negative number!"; return 0; } cout<<"Square roots are: +"<<sqrtnum(num) and <
  • 在 C++ 中找到立方根?(finding cube root in C++?)
    问题 当我试图找到一个数字的立方根时,会发生奇怪的事情。 以下代码返回我未定义。 在 cmd 中:-1.#IND cout<<pow(( double )(20.0*(-3.2) + 30.0),( double )1/3) 虽然这个工作得很好。 在 cmd 中:4.93242414866094 cout<<pow(( double )(20.0*4.5 + 30.0),( double )1/3) 从数学方式来看,它必须起作用,因为我们可以从负数得到立方根。 Pow 来自 Visual C++ 2010 math.h 库。 有任何想法吗? 回答1 如果 x 为负且 y 为非整数pow(x, y)来自<cmath> pow(x, y)不起作用。 这是std::pow的限制,如 C 标准和 cppreference 中所述: 错误处理按照 math_errhandling 中指定的方式报告错误如果 base 有限且为负,exp 有限且非整数,则会出现域错误并可能出现范围错误。 如果 base 为零且 exp 为零,则可能会出现域错误。 如果 base 为零且 exp 为负,则可能会出现域错误或极点错误。 有几种方法可以解决此限制: Cube-rooting 与将某物取 1/3 次幂相同,因此您可以执行std::pow(x, 1/3.) 。 在 C++11 中,您可以使用 std