转载-编写高效的C程序与C代码优化（三）

Terry

循环终止 / Loop termination

如果不加留意地编写循环终止条件，就可能会给程序带来明显的负担。我们应该尽量使用“倒数到零”的循环，使用简单的循环终止条件。循环终止条件相对简单，程序在执行的时候也会消耗相对少的时间。拿下面两个计算n!的例子来说，第一个例子使用递增循环，第二个使用递减循环。

int fact1_func (int n)

{

int i, fact = 1;

for (i = 1; i <= n; i++)

fact *= i;

return (fact);

}

int fact2_func(int n)

{

int i, fact = 1;

for (i = n; i != 0; i--)

fact *= i;

return (fact);

}

结果是，第二个例子要比第一个快得多。

更快的for()循环 / Faster for() loops

这是一个简单而有效的概念，通常情况下，我们习惯把for循环写成这样：

for( i = 0;  i < 10;  i++){ ... }

i 值依次为：0,1,2,3,4,5,6,7,8,9

在不在乎循环计数器顺序的情况下，我们可以这样：

for( i = 10;  i--; ) { ... }

i值依次为: 9,8,7,6,5,4,3,2,1,0,而且循环要更快

这种方法是可行的，因为它是用更快的i--作为测试条件的，也就是说“i是否为非零数，如果是减一，然后继续”。相对于原先的代码，处理器不得不“把i减去10，结果是否为非零数，如果是，增加i，然后继续”，在紧密循环(tight loop)中，这会产生显著的区别。

这种语法看起来有一点陌生，却完全合法。循环中的第三条语句是可选的（无限循环可以写成这样for(;;)）,下面的写法也可以取得同样的效果：

for(i = 10;  i;  i--){}

或者:

for(i = 10;  i != 0;  i--){}

我们唯一要小心的地方是要记住循环需要停止在0（如果循环是从50-80，这样做就不行了），而且循环的计数器为倒计数方式。

另外，我们还可以把计数器分配到寄存器上，可以产生更为有效的代码。这种将循环计数器初始化成循环次数，然后递减到零的方法，同样适用于while和do语句。

混合循环/ Loop jamming

在可以使用一个循环的场合，决不要使用两个。但是如果你要在循环中进行大量的工作，超过处理器的指令缓冲区，在这种情况下，使用两个分开的循环可能会更快，因为有可能这两个循环都被完整的保存在指令缓冲区里了。

//原先的代码

for(i = 0; i < 100; i++){

stuff();

}

for(i = 0; i < 100; i++){

morestuff();

}        

//更好的做法

for(i = 0; i < 100; i++){

stuff();

morestuff();

}

函数循环 / Function Looping

调用函数的时候，在性能上就会付出一定的代价。不光要改变程序指针，还要将那些正在使用的变量压入堆栈，分配新的变量空间。为了提高程序的效率，在程序的函数结构上，有很多工作可以做。保证程序的可读性的同时，还要尽量控制程序的大小。

如果一个函数在一个循环中被频繁调用，就可以考虑将这个循环放在函数的里面，这样可以免去重复调用函数的负担，比如：

for(i = 0 ; i < 100 ; i++)

{

func(t,i);

}

void func(int w, d)

{

lots of stuff.

}

可以写成：

func(t);

void func(w)

{

for(i = 0; i < 100; i++) {

  //lots of stuff.

}

}

展开循环 / Loop unrolling

为了提高效率，可以将小的循环解开，不过这样会增加代码的尺寸。循环被拆开后，会降低循环计数器更新的次数，减少所执行的循环的分支数目。如果循环只重复几次，那它完全可以被拆解开，这样，由循环所带来的额外开销就会消失。

比如:

for(i = 0; i < 3; i++){

something(i);

}

//更高效的方式：

something(0);

something(1);

something(2);

因为在每次的循环中，i 的值都会增加，然后检查是否有效。编译器经常会把这种简单的循环解开，前提是这些循环的次数是固定的。对于这样的循环：

for(i = 0; i <  limit; i++) { ... }

就不可能被拆解，因为我们不知道它循环的次数到底是多少。不过，将这种类型的循环拆解开并不是不可能的。

与简单循环相比，下面的代码的长度要长很多，然而具有高得多的效率。选择8作为分块大小，只是用来演示，任何合适的长度都是可行的。例子中，循环的成立条件每八次才被检验一次，而不是每次都要检验。如果需要处理的数组的大小是确定的，我们就可以使用数组的大小作为分块的大小（或者是能够整除数组长度的数值）。不过，分块的大小跟系统的缓存大小有关。

#include<stdio.H>

#define BLOCKSIZE (8)

int main(void)

{

int i = 0;

int limit = 33;  /* could be anything */

int blocklimit;

/* The limit may not be divisible by BLOCKSIZE,

go as near as we can first, then tidy up.

*/

blocklimit = (limit / BLOCKSIZE) * BLOCKSIZE;

/* unroll the loop in blocks of 8 */

while(i < blocklimit) {

  printf("process(%d)\n", i);

  printf("process(%d)\n", i+1);

  printf("process(%d)\n", i+2);

  printf("process(%d)\n", i+3);

  printf("process(%d)\n", i+4);

  printf("process(%d)\n", i+5);

  printf("process(%d)\n", i+6);

  printf("process(%d)\n", i+7);

  /* update the counter */

  i += 8;

}

/*

* There may be some left to do.

* This could be done as a simple for() loop,

* but a switch is faster (and more interesting)

*/

if( i < limit )

{

  /* Jump into the case at the place that will allow

   * us to finish off the appropriate number of items.

   */

  switch( limit - i )

  {

      case 7 : printf("process(%d)\n", i); i++;

      case 6 : printf("process(%d)\n", i); i++;

      case 5 : printf("process(%d)\n", i); i++;

      case 4 : printf("process(%d)\n", i); i++;

      case 3 : printf("process(%d)\n", i); i++;

      case 2 : printf("process(%d)\n", i); i++;

      case 1 : printf("process(%d)\n", i);

  }

}

return 0;

}