我对编译器的优化实际上没有太多经验，也不知道不同级别之间的区别（例如gcc中的-O2和-O3）。因此，我不确定对于任意一种编译器来说，下面这两个语句是否等价：
for(i=0;i<10;++i){
variable1*variable2*gridpoint[i];
}
并且
variable3=variable1*variable2;
for(i=0;i<10;++i){
variable3*gridpoint[i];
}
pure和const属性可用于特别标记应该受到此优化的函数（请参阅函数属性）。
鉴于没有副作用并且编译器能够确定它（在您的示例中，没有任何障碍），这方面的两个代码片段是等效的（我已经用clang进行了检查：-）。
然而，这需要额外的内存，我不确定优化器如何强烈地考虑这种开销。
实际上，这不需要任何额外的内存。乘法是在处理器寄存器中完成的，并且结果也存储在寄存器中。这是消除大量代码并使用单个寄存器存储结果的问题，这总是很好的（并且在寄存器分配方面肯定会使生活更轻松，特别是在循环中）。因此，如果可以进行此优化，则将不会产生额外的成本。
第一个表达式最容易阅读..
无论如何GCC和Clang都将执行此优化。但是我不确定其他编译器，所以您需要自己检查。但是很难想象没有进行子表达式消除的好编译器。
如果我将变量声明为常量，这会改变什么吗？
可能会有所不同。这被称为常量表达式，即只包含常量的表达式。常量表达式可以在编译期间而不是运行时进行评估。因此，例如，如果你将A和B都定义为常量并将它们相乘，编译器将仅预先计算A*B表达式，然后将C与该预先计算的值相乘。编译器甚至可以对非常量值进行此操作，如果它们可以确定其值在编译时且确定其不会更改。例如：
$ cat test.c
inline int foo(int a, int b)
{
return a * b;
}
int main() {
int a;
int b;
a = 1;
b = 2;
return foo(a, b);
}
$ clang -Wall -pedantic -O4 -o test ./test.c
$ otool -tv ./test
./test:
(__TEXT,__text) section
_main:
0000000100000f70 movl $0x00000002,%eax
0000000100000f75 ret
除了上述代码片段，还有其他可以进行优化的地方。以下是一些我想到的：
第一个也是最明显的是循环展开。由于迭代次数在运行时已知，编译器可以决定展开循环。是否应用此优化取决于架构（即某些CPU可以“锁定您的循环”并比其展开版本更快地执行代码，这也通过使用更少的空间、避免额外的µOP融合阶段等使代码更加缓存友好）。
第二个优化可以将速度提高50倍，即使用 SIMD指令（SSE、AVX等）。例如，GCC非常擅长这方面的优化（如果不是更好的话，英特尔也必须如此）。我已经验证了以下功能：
uint8_t dumb_checksum(const uint8_t *p, size_t size)
{
uint8_t s = 0;
size_t i;
for (i = 0; i < size; ++i)
s = (uint8_t)(s + p[i]);
return s;
}
...被转化成一个循环，每一步都会同时累加16个值（例如，像_mm_add_epi8一样），并且还有额外的代码处理对齐和奇数（<16）迭代计数。然而，最近一次检查时，Clang失败了。因此，即使迭代次数未知，GCC也可能以这种方式缩小您的循环。
如果我可以的话，我建议您不要优化代码，除非您发现它是瓶颈。否则，您可能会浪费大量时间进行虚假和过早的优化。
希望这回答了您的问题。祝你好运！
variable1等声明为const类型。 - Daniel Fischerobj->value 并执行其他操作（即调用某个函数并将 obj 传递给它），编译器将不知道值是否正在更改，并且将始终从内存中读取它，而如果您明确执行 const type var = obj->var;，它可以将此值保留在寄存器中而不是读取内存，并进行其他优化。但是，如果没有副作用并且编译器可以确定，则无关紧要。 - user405725#include <stdlib.h>
#include <time.h>
int main () {
srandom(time(NULL));
int i, ret = 0, a = random(), b = random(), values[10];
int loop_end = random() % 5 + 1000000000;
for (i=0; i < 10; ++i) { values[i] = random(); }
for (i = 0; i < loop_end; ++i) {
ret += a * b * values[i % 10];
}
return ret;
}
prog2:
#include <stdlib.h>
#include <time.h>
int main () {
srandom(time(NULL));
int i, ret = 0, a = random(), b = random(), values[10];
int loop_end = random() % 5 + 1000000000;
for (i=0; i < 10; ++i) { values[i] = random(); }
int c = a * b;
for (i = 0; i < loop_end; ++i) {
ret += c * values[i % 10];
}
return ret;
}
> gcc -O2 prog1.c -o prog1; time ./prog1
./prog1 1.62s user 0.00s system 99% cpu 1.630 total
> gcc -O2 prog2.c -o prog2; time ./prog2
./prog2 1.63s user 0.00s system 99% cpu 1.636 total
这是测量墙钟时间（wall time），因此不要关注0.01秒的差异，运行几次后它们都在1.62-1.63秒范围内波动，因此速度相同。
有趣的是，当没有进行优化编译时，prog1更快。
> gcc -O0 prog1.c -o prog1; time ./prog1
./prog1 2.83s user 0.00s system 99% cpu 2.846 total
> gcc -O0 prog2.c -o prog2; time ./prog2
./prog2 2.93s user 0.00s system 99% cpu 2.946 total
-O1编译提供了最佳性能。gcc -O1 prog1.c -o prog1; time ./prog1
./prog1 1.57s user 0.00s system 99% cpu 1.579 total
gcc -O1 prog2.c -o prog2; time ./prog2
./prog2 1.56s user 0.00s system 99% cpu 1.563 total
GCC和Intel都是优秀的编译器，对于这样的工作非常聪明。我没有使用过Portland编译器，但这些对于一个编译器来说都是基本的操作，所以如果它不能很好地处理这种情况，我会感到非常惊讶。
volatile变量是与内存空间的一个区域相关联的变量，它可以在代码正常流程之外发生变化...例如，映射到微处理器的输入寄存器的变量，或者映射到时钟寄存器的变量。因此，每次访问它时，它可能已经改变，即使没有代码分配给它一个值。因此，编译器不会将其提取到循环的外部。 - Dancrumb