代码优化方案

时间 2019-11-09

标签代码优化方案繁體版

原文原文链接

转载自：http://www.uml.org.cn/c++/200811103.asp#_Toc110958704

一、选择合适的算法和数据结构

选择一种合适的数据结构很重要，若是在一堆随机存放的数中使用了大量的插入和删除指令，那使用链表要快得多。数组与指针语句具备十分密切的关系，通常来讲，指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。c++

在许多种状况下，能够用指针运算代替数组索引，这样作经常能产生又快又短的代码。与数组索引相比，指针通常能使代码速度更快，占用空间更少。使用多维数组时差别更明显。下面的代码做用是相同的，可是效率不同�程序员

数组索引

指针运算

For(;;){算法

A=array[t++];编程

。。。。。。。。。数组

}缓存

p=array数据结构

for(;;){模块化

a=*(p++);函数

。。。。。。。。。oop

}

指针方法的优势是，array的地址每次装入地址p后，在每次循环中只需对p增量操做。在数组索引方法中，每次循环中都必须根据t值求数组下标的复杂运算。

二、使用尽可能小的数据类型

可以使用字符型(char)定义的变量，就不要使用整型(int)变量来定义；可以使用整型变量定义的变量就不要用长整型(long int)，能不使用浮点型(float)变量就不要使用浮点型变量。固然，在定义变量后不要超过变量的做用范围，若是超过变量的范围赋值，C编译器并不报错，但程序运行结果却错了，并且这样的错误很难发现。

在ICCAVR中，能够在Options中设定使用printf参数，尽可能使用基本型参数(%c、%d、%x、%X、%u和%s格式说明符)，少用长整型参数(%ld、%lu、%lx和%lX格式说明符)，至于浮点型的参数(%f)则尽可能不要使用，其它C编译器也同样。在其它条件不变的状况下，使用%f参数，会使生成的代码的数量增长不少，执行速度下降。

三、减小运算的强度

（1）、查表(游戏程序员必修课)

一个聪明的游戏大虾，基本上不会在本身的主循环里搞什么运算工做，绝对是先计算好了，再到循环里查表。看下面的例子：

旧代码：

    long factorial(int i)

    {

        if (i == 0)

            return 1;

        else

            return i * factorial(i - 1);

    }

新代码：

    static long factorial_table[] =

        {1， 1， 2， 6， 24， 120， 720  /* etc */ };

    long factorial(int i)

    {

        return factorial_table[i];

    }

若是表很大，很差写，就写一个init函数，在循环外临时生成表格。

（2）、求余运算

a=a%8;

能够改成：

a=a&7;

说明：位操做只需一个指令周期便可完成，而大部分的C编译器的“%”运算均是调用子程序来完成，代码长、执行速度慢。一般，只要求是求2n方的余数，都可使用位操做的方法来代替。

（3）、平方运算

a=pow(a, 2.0);

能够改成：

a=a*a;

说明：在有内置硬件乘法器的单片机中(如51系列)，乘法运算比求平方运算快得多，由于浮点数的求平方是经过调用子程序来实现的，在自带硬件乘法器的AVR单片机中，如ATMega163中，乘法运算只需2个时钟周期就能够完成。既使是在没有内置硬件乘法器的AVR单片机中，乘法运算的子程序比平方运算的子程序代码短，执行速度快。

若是是求3次方，如：

a=pow(a，3。0);

更改成：

a=a*a*a；

则效率的改善更明显。

（4）、用移位实现乘除法运算

a=a*4; b=b/4;

能够改成：

a=a<<2; b=b>>2;

一般若是须要乘以或除以2n，均可以用移位的方法代替。在ICCAVR中，若是乘以2n，均可以生成左移的代码，而乘以其它的整数或除以任何数，均调用乘除法子程序。用移位的方法获得代码比调用乘除法子程序生成的代码效率高。实际上，只要是乘以或除以一个整数，都可以用移位的方法获得结果，如：

a=a*9

能够改成：

a=(a<<3)+a

采用运算量更小的表达式替换原来的表达式，下面是一个经典例子:

旧代码:

    x = w % 8;

    y = pow(x， 2.0);

    z = y * 33;

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

    {

        h = 14 * i;

        printf("%d"， h);

    }

新代码:

    x = w & 7;              /* 位操做比求余运算快*/

    y = x * x;               /* 乘法比平方运算快*/

    z = (y << 5) + y;          /* 位移乘法比乘法快 */

    for (i = h = 0; i < MAX; i++)

    {

        h += 14;                /* 加法比乘法快 */

        printf("%d"，h);

}

（5）、避免没必要要的整数除法

整数除法是整数运算中最慢的，因此应该尽量避免。一种可能减小整数除法的地方是连除，这里除法能够由乘法代替。这个替换的反作用是有可能在算乘积时会溢出，因此只能在必定范围的除法中使用。

很差的代码：

int , j, k, m;

m = i / j / k;

推荐的代码：

int i， j, k, m;

m = i / (j * k);

（6）、使用增量和减量操做符

在使用到加一和减一操做时尽可能使用增量和减量操做符，由于增量符语句比赋值语句更快，缘由在于对大多数CPU来讲，对内存字的增、减量操做没必要明显地使用取内存和写内存的指令，好比下面这条语句：

x=x+1;

模仿大多数微机汇编语言为例，产生的代码相似于：

move A，x      ;把x从内存取出存入累加器A

add A，1        ;累加器A加1

store x          ;把新值存回x

若是使用增量操做符，生成的代码以下：

incr x ;x加1

显然，不用取指令和存指令，增、减量操做执行的速度加快，同时长度也缩短了。

（7）、使用复合赋值表达式

复合赋值表达式(如a-=1及a+=1等)都可以生成高质量的程序代码。

（8）、提取公共的子表达式

在某些状况下，C++编译器不能从浮点表达式中提出公共的子表达式，由于这意味着至关于对表达式从新排序。须要特别指出的是，编译器在提取公共子表达式前不能按照代数的等价关系从新安排表达式。这时，程序员要手动地提出公共的子表达式（在VC.NET里有一项“全局优化”选项能够完成此工做，但效果就不得而知了）。

很差的代码：

float a， b， c， d， e， f；

。。。

e = b * c / d；

f = b / d * a；

推荐的代码：

float a， b， c， d， e， f；

。。。

const float t(b / d)；

e = c * t；

f = a * t；

很差的代码：

float a， b， c， e， f；

。。。

e = a / c；

f = b / c；

推荐的代码：

float a， b， c， e， f；

。。。

const float t(1.0f / c)；

e = a * t；

f = b * t；

四、结构体成员的布局

不少编译器有“使结构体字，双字或四字对齐”的选项。可是，仍是须要改善结构体成员的对齐，有些编译器可能分配给结构体成员空间的顺序与他们声明的不一样。可是，有些编译器并不提供这些功能，或者效果很差。因此，要在付出最少代价的状况下实现最好的结构体和结构体成员对齐，建议采起下列方法：

（1）按数据类型的长度排序

把结构体的成员按照它们的类型长度排序，声明成员时把长的类型放在短的前面。编译器要求把长型数据类型存放在偶数地址边界。在申明一个复杂的数据类型 (既有多字节数据又有单字节数据) 时，应该首先存放多字节数据，而后再存放单字节数据，这样能够避免内存的空洞。编译器自动地把结构的实例对齐在内存的偶数边界。

（2）把结构体填充成最长类型长度的整倍数

把结构体填充成最长类型长度的整倍数。照这样，若是结构体的第一个成员对齐了，全部整个结构体天然也就对齐了。下面的例子演示了如何对结构体成员进行从新排序：

很差的代码，普通顺序：

struct

{

char a[5]；

long k；

double x；

} baz；

推荐的代码，新的顺序并手动填充了几个字节：

struct

{

double x；

long k；

char a[5]；

char pad[7]；

} baz；

这个规则一样适用于类的成员的布局。

（3）按数据类型的长度排序本地变量

当编译器分配给本地变量空间时，它们的顺序和它们在源代码中声明的顺序同样，和上一条规则同样，应该把长的变量放在短的变量前面。若是第一个变量对齐了，其它变量就会连续的存放，并且不用填充字节天然就会对齐。有些编译器在分配变量时不会自动改变变量顺序，有些编译器不能产生4字节对齐的栈，因此4字节可能不对齐。下面这个例子演示了本地变量声明的从新排序：

很差的代码，普通顺序

short ga， gu， gi；

long foo， bar；

double x， y， z[3]；

char a， b；

float baz；

推荐的代码，改进的顺序

double z[3]；

double x， y；

long foo， bar；

float baz；

short ga， gu， gi；

（4）把频繁使用的指针型参数拷贝到本地变量

避免在函数中频繁使用指针型参数指向的值。由于编译器不知道指针之间是否存在冲突，因此指针型参数每每不能被编译器优化。这样数据不能被存放在寄存器中，并且明显地占用了内存带宽。注意，不少编译器有“假设不冲突”优化开关（在VC里必须手动添加编译器命令行/Oa或/Ow），这容许编译器假设两个不一样的指针老是有不一样的内容，这样就不用把指针型参数保存到本地变量。不然，请在函数一开始把指针指向的数据保存到本地变量。若是须要的话，在函数结束前拷贝回去。

很差的代码：

// 假设 q != r

void isqrt(unsigned long a， unsigned long* q， unsigned long* r)

{

　　*q = a；

　　if (a > 0)

　　{

　　　　while (*q > (*r = a / *q))

　　　　{

　　　　　　*q = (*q + *r) >> 1；

　　　　}

　　}

　　*r = a - *q * *q；

}

推荐的代码：

// 假设 q != r

void isqrt(unsigned long a， unsigned long* q， unsigned long* r)

{

　　unsigned long qq， rr；

　　qq = a；

　　if (a > 0)

　　{

　　　　while (qq > (rr = a / qq))

　　　　{

　　　　　　qq = (qq + rr) >> 1；

　　　　}

　　}

　　rr = a - qq * qq；

　　*q = qq；

　　*r = rr；

}

五、循环优化

（1）、充分分解小的循环

要充分利用CPU的指令缓存，就要充分分解小的循环。特别是当循环体自己很小的时候，分解循环能够提升性能。注意:不少编译器并不能自动分解循环。很差的代码：

// 3D转化：把矢量 V 和 4x4 矩阵 M 相乘

for (i = 0； i < 4； i ++)

{

　　r[i] = 0；

　　for (j = 0； j < 4； j ++)

　　{

　　　　r[i] += M[j][i]*V[j]；

　　}

}

推荐的代码：

r[0] = M[0][0]*V[0] + M[1][0]*V[1] + M[2][0]*V[2] + M[3][0]*V[3]；

r[1] = M[0][1]*V[0] + M[1][1]*V[1] + M[2][1]*V[2] + M[3][1]*V[3]；

r[2] = M[0][2]*V[0] + M[1][2]*V[1] + M[2][2]*V[2] + M[3][2]*V[3]；

r[3] = M[0][3]*V[0] + M[1][3]*V[1] + M[2][3]*V[2] + M[3][3]*v[3]；

（2）、提取公共部分

对于一些不须要循环变量参加运算的任务能够把它们放到循环外面，这里的任务包括表达式、函数的调用、指针运算、数组访问等，应该将没有必要执行屡次的操做所有集合在一块儿，放到一个init的初始化程序中进行。

（3）、延时函数

一般使用的延时函数均采用自加的形式：

    void delay (void)

    {

unsigned int i;

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

    }

将其改成自减延时函数：

    void delay (void)

    {

unsigned int i;

        for (i=1000;i>0;i--) ;

    }

两个函数的延时效果类似，但几乎全部的C编译对后一种函数生成的代码均比前一种代码少1~3个字节，由于几乎全部的MCU均有为0转移的指令，采用后一种方式可以生成这类指令。在使用while循环时也同样，使用自减指令控制循环会比使用自加指令控制循环生成的代码更少1~3个字母。可是在循环中有经过循环变量“i”读写数组的指令时，使用预减循环有可能使数组超界，要引发注意。

（4）、while循环和do…while循环

用while循环时有如下两种循环形式：

unsigned int i;

    i=0;

    while (i<1000)

    {

        i++;

           //用户程序

    }

或：

unsigned int i;

    i=1000;

do

{

          i--;

          //用户程序

}

while (i>0);

在这两种循环中，使用do…while循环编译后生成的代码的长度短于while循环。

（6）、循环展开

这是经典的速度优化，但许多编译程序(如gcc -funroll-loops)能自动完成这个事，因此如今你本身来优化这个显得效果不明显。

旧代码:

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

{

do_stuff(i);

}

新代码:

for (i = 0; i < 100; )

{

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

do_stuff(i); i++;

}

能够看出，新代码里比较指令由100次下降为10次，循环时间节约了90%。不过注意:对于中间变量或结果被更改的循环，编译程序每每拒绝展开，(怕担责任呗)，这时候就须要你本身来作展开工做了。

还有一点请注意，在有内部指令cache的CPU上(如MMX芯片)，由于循环展开的代码很大，每每cache溢出，这时展开的代码会频繁地在CPU 的cache和内存之间调来调去，又由于cache速度很高，因此此时循环展开反而会变慢。还有就是循环展开会影响矢量运算优化。

（6）、循环嵌套

把相关循环放到一个循环里，也会加快速度。

旧代码:

for (i = 0; i < MAX; i++)         /* initialize 2d array to 0's */

    for (j = 0; j < MAX; j++)

        a[i][j] = 0.0;

    for (i = 0; i < MAX; i++)        /* put 1's along the diagonal */

        a[i][i] = 1.0;

新代码:

for (i = 0; i < MAX; i++)         /* initialize 2d array to 0's */

{

    for (j = 0; j < MAX; j++)

        a[i][j] = 0.0;

    a[i][i] = 1.0;                            /* put 1's along the diagonal */

}

（7）、Switch语句中根据发生频率来进行case排序

Switch 可能转化成多种不一样算法的代码。其中最多见的是跳转表和比较链/树。当switch用比较链的方式转化时，编译器会产生if-else-if的嵌套代码，并按照顺序进行比较，匹配时就跳转到知足条件的语句执行。因此能够对case的值依照发生的可能性进行排序，把最有可能的放在第一位，这样能够提升性能。此外，在case中推荐使用小的连续的整数，由于在这种状况下，全部的编译器均可以把switch 转化成跳转表。

很差的代码：

int days_in_month， short_months， normal_months， long_months；

。。。。。。

switch (days_in_month)

{

　　case 28:

　　case 29:

　　　　short_months ++；

　　　　break；

　　case 30:

　　　　normal_months ++；

　　　　break；

　　case 31:

　　　　long_months ++；

　　　　break；

　　default:

　　　　cout << "month has fewer than 28 or more than 31 days" << endl；

　　　　break；

}

推荐的代码：

int days_in_month， short_months， normal_months， long_months；

。。。。。。

switch (days_in_month)

{

　　case 31:

　　　　long_months ++；

　　　　break；

　　case 30:

　　　　normal_months ++；

　　　　break；

　　case 28:

　　case 29:

　　　　short_months ++；

　　　　break；

　　default:

　　　　cout << "month has fewer than 28 or more than 31 days" << endl；

　　　　break；

}

（8）、将大的switch语句转为嵌套switch语句

当switch语句中的case标号不少时，为了减小比较的次数，明智的作法是把大switch语句转为嵌套switch语句。把发生频率高的case 标号放在一个switch语句中，而且是嵌套switch语句的最外层，发生相对频率相对低的case标号放在另外一个switch语句中。好比，下面的程序段把相对发生频率低的状况放在缺省的case标号内。

pMsg=ReceiveMessage();

        switch (pMsg->type)

        {

        case FREQUENT_MSG1:

        handleFrequentMsg();

        break;

        case FREQUENT_MSG2:

        handleFrequentMsg2();

        break;

        。。。。。。

        case FREQUENT_MSGn:

        handleFrequentMsgn();

        break;

        default:                     //嵌套部分用来处理不常常发生的消息

        switch (pMsg->type)

        {

        case INFREQUENT_MSG1:

        handleInfrequentMsg1();

        break;

        case INFREQUENT_MSG2:

        handleInfrequentMsg2();

        break;

        。。。。。。

        case INFREQUENT_MSGm:

        handleInfrequentMsgm();

        break;

        }

        }

若是switch中每一种状况下都有不少的工做要作，那么把整个switch语句用一个指向函数指针的表来替换会更加有效，好比下面的switch语句，有三种状况：

enum MsgType{Msg1， Msg2， Msg3}

        switch (ReceiveMessage()

        {

        case Msg1;

        。。。。。。

        case Msg2;

        。。。。。

        case Msg3;

        。。。。。

        }

为了提升执行速度，用下面这段代码来替换这个上面的switch语句。

        /*准备工做*/

        int handleMsg1(void);

        int handleMsg2(void);

        int handleMsg3(void);

        /*建立一个函数指针数组*/

        int (*MsgFunction [])()={handleMsg1， handleMsg2， handleMsg3};

        /*用下面这行更有效的代码来替换switch语句*/

        status=MsgFunction[ReceiveMessage()]();

（9）、循环转置

有些机器对JNZ(为0转移)有特别的指令处理，速度很是快，若是你的循环对方向不敏感，能够由大向小循环。

旧代码:

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

{

   。。。

 }

新代码:

i = MAX+1;

while (--i)

{

。。。

}

不过千万注意，若是指针操做使用了i值，这种方法可能引发指针越界的严重错误(i = MAX+1;)。固然你能够经过对i作加减运算来纠正，可是这样就起不到加速的做用，除非相似于如下状况：

旧代码:

char a[MAX+5];

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

{

*(a+i+4)=0;

}

新代码:

i = MAX+1;

while (--i)

{

      *(a+i+4)=0;

}

（10）、公用代码块

一些公用处理模块，为了知足各类不一样的调用须要，每每在内部采用了大量的if-then-else结构，这样很很差，判断语句若是太复杂，会消耗大量的时间的，应该尽可能减小公用代码块的使用。(任何状况下，空间优化和时间优化都是对立的--东楼)。固然，若是仅仅是一个(3==x)之类的简单判断，适当使用一下，也仍是容许的。记住，优化永远是追求一种平衡，而不是走极端。

（11）提高循环的性能

要提高循环的性能，减小多余的常量计算很是有用（好比，不随循环变化的计算）。

很差的代码(在for()中包含不变的if())：

for( i 。。。 )

{

　　if( CONSTANT0 )

　　{

　　　　DoWork0( i )； // 假设这里不改变CONSTANT0的值

　　}

　　else

　　{

　　　　DoWork1( i )； // 假设这里不改变CONSTANT0的值

　　}

}

推荐的代码：

if( CONSTANT0 )

{

　　for( i 。。。 )

　　{

　　　　DoWork0( i )；

　　}

}

else

{

　　for( i 。。。 )

　　{

　　　　DoWork1( i )；

　　}

}

若是已经知道if()的值，这样能够避免重复计算。虽然很差的代码中的分支能够简单地预测，可是因为推荐的代码在进入循环前分支已经肯定，就能够减小对分支预测的依赖。

（12）、选择好的无限循环

在编程中，咱们经常须要用到无限循环，经常使用的两种方法是while (1) 和 for (；；)。这两种方法效果彻底同样，但那一种更好呢？然咱们看看它们编译后的代码：

编译前：

while (1)；

编译后：

mov eax，1

test eax，eax

je foo+23h

jmp foo+18h

编译前：

for (；；)；

编译后：

jmp foo+23h

显然，for (；；)指令少，不占用寄存器，并且没有判断、跳转，比while (1)好。

六、提升CPU的并行性

（1）使用并行代码

尽量把长的有依赖的代码链分解成几个能够在流水线执行单元中并行执行的没有依赖的代码链。不少高级语言，包括C++，并不对产生的浮点表达式从新排序，由于那是一个至关复杂的过程。须要注意的是，重排序的代码和原来的代码在代码上一致并不等价于计算结果一致，由于浮点操做缺少精确度。在一些状况下，这些优化可能致使意料以外的结果。幸运的是，在大部分状况下，最后结果可能只有最不重要的位（即最低位）是错误的。

很差的代码：

double a[100]， sum；

int i；

sum = 0.0f；

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

sum += a[i]；

推荐的代码：

double a[100]， sum1， sum2， sum3， sum4， sum；

int i；

sum1 = sum2 = sum3 = sum4 = 0.0；

for (i = 0； i < 100； i += 4)

{

　　sum1 += a[i]；

　　sum2 += a[i+1]；

　　sum3 += a[i+2]；

　　sum4 += a[i+3]；

}

sum = (sum4+sum3)+(sum1+sum2)；

要注意的是：使用4路分解是由于这样使用了4段流水线浮点加法，浮点加法的每个段占用一个时钟周期，保证了最大的资源利用率。

（2）避免没有必要的读写依赖

当数据保存到内存时存在读写依赖，即数据必须在正确写入后才能再次读取。虽然AMD Athlon等CPU有加速读写依赖延迟的硬件，容许在要保存的数据被写入内存前读取出来，可是，若是避免了读写依赖并把数据保存在内部寄存器中，速度会更快。在一段很长的又互相依赖的代码链中，避免读写依赖显得尤为重要。若是读写依赖发生在操做数组时，许多编译器不能自动优化代码以免读写依赖。因此推荐程序员手动去消除读写依赖，举例来讲，引进一个能够保存在寄存器中的临时变量。这样能够有很大的性能提高。下面一段代码是一个例子：

很差的代码：

float x[VECLEN]， y[VECLEN]， z[VECLEN]；

。。。。。。

for (unsigned int k = 1； k < VECLEN； k ++)

{

　　x[k] = x[k-1] + y[k]；

}

for (k = 1； k <VECLEN； k++)

{

　　x[k] = z[k] * (y[k] - x[k-1])；

}

推荐的代码：

float x[VECLEN]， y[VECLEN]， z[VECLEN]；

。。。。。。

float t(x[0])；

for (unsigned int k = 1； k < VECLEN； k ++)

{

　　t = t + y[k]；

　　x[k] = t；

}

t = x[0]；

for (k = 1； k <； VECLEN； k ++)

{

　　t = z[k] * (y[k] - t)；

　　x[k] = t；

}

七、循环不变计算

对于一些不须要循环变量参加运算的计算任务能够把它们放到循环外面，如今许多编译器仍是能本身干这件事，不过对于中间使用了变量的算式它们就不敢动了，因此不少状况下你还得本身干。对于那些在循环中调用的函数，凡是不必执行屡次的操做统统提出来，放到一个init函数里，循环前调用。另外尽可能减小喂食次数，不必的话尽可能不给它传参，须要循环变量的话让它本身创建一个静态循环变量本身累加，速度会快一点。

还有就是结构体访问，东楼的经验，凡是在循环里对一个结构体的两个以上的元素执行了访问，就有必要创建中间变量了(结构这样，那C++的对象呢?想一想看)，看下面的例子:

旧代码:

    total =

    a->b->c[4]->aardvark +

    a->b->c[4]->baboon +

    a->b->c[4]->cheetah +

    a->b->c[4]->dog;

新代码:

    struct animals * temp = a->b->c[4];

    total =

    temp->aardvark +

    temp->baboon +

    temp->cheetah +

    temp->dog;

一些老的C语言编译器不作聚合优化，而符合ANSI规范的新的编译器能够自动完成这个优化，看例子:

    float a， b， c， d， f， g;

    。。。

    a = b / c * d;

    f = b * g / c;

这种写法固然要得，可是没有优化

    float a， b， c， d， f， g;

    。。。

    a = b / c * d;

    f = b / c * g;

若是这么写的话，一个符合ANSI规范的新的编译器能够只计算b/c一次，而后将结果代入第二个式子，节约了一次除法运算。

八、函数优化

（1）Inline函数

在C++中，关键字Inline能够被加入到任何函数的声明中。这个关键字请求编译器用函数内部的代码替换全部对于指出的函数的调用。这样作在两个方面快于函数调用：第一，省去了调用指令须要的执行时间；第二，省去了传递变元和传递过程须要的时间。可是使用这种方法在优化程序速度的同时，程序长度变大了，所以须要更多的ROM。使用这种优化在Inline函数频繁调用而且只包含几行代码的时候是最有效的。

（2）不定义不使用的返回值

函数定义并不知道函数返回值是否被使用，假如返回值历来不会被用到，应该使用void来明确声明函数不返回任何值。

（3）减小函数调用参数

使用全局变量比函数传递参数更加有效率。这样作去除了函数调用参数入栈和函数完成后参数出栈所须要的时间。然而决定使用全局变量会影响程序的模块化和重入，故要慎重使用。

（4）全部函数都应该有原型定义

通常来讲，全部函数都应该有原型定义。原型定义能够传达给编译器更多的可能用于优化的信息。

（5）尽量使用常量(const)

尽量使用常量(const)。C++ 标准规定，若是一个const声明的对象的地址不被获取，容许编译器不对它分配储存空间。这样可使代码更有效率，并且能够生成更好的代码。

（6）把本地函数声明为静态的(static)

若是一个函数只在实现它的文件中被使用，把它声明为静态的(static)以强制使用内部链接。不然，默认的状况下会把函数定义为外部链接。这样可能会影响某些编译器的优化——好比，自动内联。

九、采用递归

与LISP之类的语言不一样，C语言一开始就病态地喜欢用重复代码循环，许多C程序员都是除非算法要求，坚定不用递归。事实上，C编译器们对优化递归调用一点都不反感，相反，它们还很喜欢干这件事。只有在递归函数须要传递大量参数，可能形成瓶颈的时候，才应该使用循环代码，其余时候，仍是用递归好些。

十、变量

（1）register变量

在声明局部变量的时候可使用register关键字。这就使得编译器把变量放入一个多用途的寄存器中，而不是在堆栈中，合理使用这种方法能够提升执行速度。函数调用越是频繁，越是可能提升代码的速度。

在最内层循环避免使用全局变量和静态变量，除非你能肯定它在循环周期中不会动态变化，大多数编译器优化变量都只有一个办法，就是将他们置成寄存器变量，而对于动态变量，它们干脆放弃对整个表达式的优化。尽可能避免把一个变量地址传递给另外一个函数，虽然这个还很经常使用。C语言的编译器们老是先假定每个函数的变量都是内部变量，这是由它的机制决定的，在这种状况下，它们的优化完成得最好。可是，一旦一个变量有可能被别的函数改变，这帮兄弟就不再敢把变量放到寄存器里了，严重影响速度。看例子：

a = b();

c(&d);

由于d的地址被c函数使用，有可能被改变，编译器不敢把它长时间的放在寄存器里，一旦运行到c(&d)，编译器就把它放回内存，若是在循环里，会形成N次频繁的在内存和寄存器之间读写d的动做，众所周知，CPU在系统总线上的读写速度慢得很。好比你的赛杨300，CPU主频300，总线速度最多66M，为了一个总线读，CPU可能要等4-5个周期，得。。得。。得。。想起来都打颤。

（2）、同时声明多个变量优于单独声明变量

（3）、短变量名优于长变量名，应尽可能使变量名短一点

（4）、在循环开始前声明变量

十一、使用嵌套的if结构

在if结构中若是要判断的并列条件较多，最好将它们拆分红多个if结构，而后嵌套在一块儿，这样能够避免无谓的判断。

说明：

上面的优化方案由王全明收集整理。不少资料来源与网上，出处不祥，在此对全部做者一并致谢！

该方案主要是考虑到在嵌入式开发中对程序执行速度的要求特别高，因此该方案主要是为了优化程序的执行速度。

注意：优化是有侧重点的，优化是一门平衡的艺术，它每每要以牺牲程序的可读性或者增长代码长度为代价。

(任何状况下，空间优化和时间优化都是对立的--东楼)。