Fortran（为科学计算而设计）有一个内置的幂运算符，据我所知，Fortran编译器通常会以与您描述的方式类似的方式优化整数幂的提升。不幸的是，C/C++没有幂运算符，只有库函数pow（）。这并不妨碍智能编译器专门处理pow，并在特殊情况下以更快的方式计算pow，但它们似乎不太常用。。。

几年前，我试图使以最佳方式计算整数幂更方便，并提出了以下建议。它是C++，而不是C，并且仍然取决于编译器在如何优化/内联方面有点聪明。无论如何，希望你能在实践中发现它有用：

template<unsigned N> struct power_impl;

template<unsigned N> struct power_impl {
    template<typename T>
    static T calc(const T &x) {
        if (N%2 == 0)
            return power_impl<N/2>::calc(x*x);
        else if (N%3 == 0)
            return power_impl<N/3>::calc(x*x*x);
        return power_impl<N-1>::calc(x)*x;
    }
};

template<> struct power_impl<0> {
    template<typename T>
    static T calc(const T &) { return 1; }
};

template<unsigned N, typename T>
inline T power(const T &x) {
    return power_impl<N>::calc(x);
}

为好奇的人澄清：这并没有找到计算幂的最佳方法，但由于找到最佳解是一个NP完全问题，而且这只值得对小幂做（而不是使用pow），因此没有理由大惊小怪。

然后将其用作功率<6>（a）。

这样可以很容易地输入幂（不需要像用括号一样拼出6），并且可以在不使用数学的情况下进行这种优化，以防出现精度相关的情况，例如补偿求和（这是一个操作顺序至关重要的示例）。

您可能也会忘记这是C++，而只是在C程序中使用它（如果它是用C++编译器编译的）。

希望这能有用。

编辑：

这是我从编译器中得到的：

对于a*a*a*a*a*a，

    movapd  %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0

对于（a*a*a）*（a*a*a），

    movapd  %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm0, %xmm0

对于功率<6>（a），

    mulsd   %xmm0, %xmm0
    movapd  %xmm0, %xmm1
    mulsd   %xmm0, %xmm1
    mulsd   %xmm0, %xmm1

另一个类似的情况是：大多数编译器不会将a+b+c+d优化为（a+b）+（c+d）（这是一种优化，因为第二个表达式可以更好地进行流水线处理），并按照给定的方式对其求值（即（（（a+c）+d））。这也是因为角落案例：

float a = 1e35, b = 1e-5, c = -1e35, d = 1e-5;
printf("%e %e\n", a + b + c + d, (a + b) + (c + d));

这将输出1.00000e-05 0.000000e+00

gcc实际上可以进行这种优化，即使对于浮点数也是如此。例如

double foo(double a) {
  return a*a*a*a*a*a;
}

变成

foo(double):
    mulsd   %xmm0, %xmm0
    movapd  %xmm0, %xmm1
    mulsd   %xmm0, %xmm1
    mulsd   %xmm1, %xmm0
    ret

使用-O-funcafe数学优化。但是，这种重新排序违反了IEEE-754，因此需要标记。

正如Peter Cordes在一篇评论中指出的，有符号整数可以在没有funsafe数学优化的情况下进行这种优化，因为它恰好在没有溢出的情况下有效，如果有溢出，则会出现未定义的行为。所以你得到

foo(long):
    movq    %rdi, %rax
    imulq   %rdi, %rax
    imulq   %rdi, %rax
    imulq   %rax, %rax
    ret

只需-O。对于无符号整数，这更容易，因为它们是2的模幂，因此即使在溢出的情况下也可以自由地重新排序。

我根本不会期望这种情况得到优化。表达式中包含可以重新组合以删除整个操作的子表达式的情况不太常见。我希望编译器编写者将他们的时间投入到更有可能带来显著改进的领域，而不是涵盖很少遇到的边缘情况。

我惊讶地从其他答案中得知，这个表达式确实可以通过适当的编译器开关进行优化。要么优化是微不足道的，要么是更常见的优化的边缘情况，要么编译器编写者非常彻底。

像您在这里所做的那样，向编译器提供提示没有错。重新排列语句和表达式，看看它们会带来什么差异，这是微优化过程中的一个正常和预期的部分。

虽然编译器可能有理由考虑这两个表达式以提供不一致的结果（没有适当的开关），但您无需受到该限制的约束。差异将非常小，以至于如果差异对你很重要，你不应该首先使用标准的浮点运算。

像“pow”这样的库函数通常经过精心设计，以产生最小可能的错误（在一般情况下）。这通常是用样条逼近函数实现的（根据Pascal的评论，最常见的实现似乎是使用Remez算法）

基本上是以下操作：

pow(x,y);

具有与任何单个乘法或除法中的误差大致相同大小的固有误差。

执行以下操作时：

float a=someValue;
float b=a*a*a*a*a*a;

其固有误差大于单个乘法或除法的误差的5倍（因为您组合了5个乘法）。

编译器应该非常小心它正在进行的优化：

如果将pow（a，6）优化为a*a*a*a*a*a，可能会提高性能，但会大大降低浮点数的精度。如果将a*a*a*a*a*a优化为pow（a，6），实际上可能会降低精度，因为“a”是一个特殊的值，它允许无误差的乘法（2的幂或一些小整数）如果将pow（a，6）优化为（a*a*a）*（a*a*a）或（a*a）*。

一般来说，您知道对于任意浮点值，“pow”的精度比您最终可以编写的任何函数都要高，但在某些特殊情况下，多次乘法可能具有更好的精度和性能，这取决于开发人员选择更合适的方法，最终对代码进行注释，以便其他人不会“优化”该代码。

唯一有意义的优化（个人观点，显然是GCC中没有任何特定优化或编译器标志的选择）应该是将“pow（a，2）”替换为“a*a”。这将是编译器供应商应该做的唯一明智的事情。

因为浮点数学不是关联的。浮点乘法中操作数的分组方式会影响答案的数值精度。

因此，大多数编译器对重新排序浮点计算非常保守，除非他们能够确定答案不变，或者除非你告诉他们你不在乎数值精度。例如：gcc的-fassociative math选项允许gcc重新关联浮点运算，或者甚至-fast math选项，允许更积极地权衡精度与速度。