嵌入式开发基本都会选择C语言
这是因为C语言有出色的可移植性
能在多种不同体系结构的软/硬平台上运行
' `. `" J' W* a: \" {虽然代码的复用性差代码的维护性差扩展性很差
但，C语言简洁紧凑
3 @, I: N0 d$ S5 _使用灵活的语法机制
并且，C语言具有很高的运行效率
那么如何保证C语言的执行效率？
嵌入式ARM告诉你！
2 c( ^2 x8 f7 U1 G! C

01

C代码执行效率与哪些因素有关

C代码执行效率与时间复杂度和空间复杂度有关：
4 x) v8 p. X+ b' m9 Z1、空间复杂度是指算法在计算机内执行时所需存储空间的度量
0 i6 a5 M. |: G2 ]0 I3 l& n1 r2、一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。
记作T(n)=Ｏ(f(n)),称Ｏ(f(n))为算法的渐进时间复杂度，简称时间复杂度。在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。
, ~. X6 w+ H5 ?$ `( j按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n),线性对数阶O(nlog2n)，平方阶O(n^2)，立方阶O(n^3),。。。，k次方阶O(n^k)，指数阶O(2^n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

02

保障C代码执行效率的原则
+ m* l4 m0 [* R' m9 Z* w

, w$ Y( U' r- T& y6 Q# q1、选择合适的算法和数据结构
. e" U' R% L, K' Q% q) P选择一种合适的数据结构很重要，如果在一堆随机存放的数中使用了大量的插入和删除指令，那使用链表要快得多。数组与指针语句具有十分密切的关系，一般来说，指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。
6 Z" g' J2 P! i1 o/ }- Y
( X' q; A& b2 {1 ^& K在许多种情况下，可以用指针运算代替数组索引，这样做常常能产生又快又短的代码。与数组索引相比，指针一般能使代码速度更快，占用空间更少。使用多维数组时差异更明显。下面的代码作用是相同的，但是效率不一样。
. n& Z* v0 K6 L2 z0 v3 U

1. 
   
2.     数组索引                指针运算
   
3.     For(;;){                p=array
   
4.     A=array[t++];          for(;;){
   0 U# e/ n6 X& a* m
5.                                 a=*(p++);
   
6.     。。。。。。。。。。。。。。。
   6 N( x8 C- |, @' h% l' A" N( P; m. v
7.     }                      }

复制代码

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

时间复杂度更低、效率更高的算法可以提高执行效率。一个简单的例子，计算1~100这些数的和，可以循环100次，也可以直接使用求和公式，在执行效率上，是显而易见的。
! h: f; W  Y+ E5 C6 ?2、代码尽量简洁，避免重复

# g! ]1 D# M3 ]3 G

在10天学会单片机那本书上看到写的数码管显示那部分代码，选中一个位，然后送数据，再选中一个位，再送数据，依次做完。代码重复率太高了，不仅占用过多的类存，而且执行效率差可读性差，仅仅是实现了功能而已，实际的编程可以做一个循环，for循环或者while循环。这样的代码看起来更有水平。
7 ~( ]( G# m# w& c) B# j1 ^1 R3、合理使用宏定义
在程序中如果某个变量或寄存器经常用到，可以使用宏定义定义一个新的名代替它。这样的好处是方便修改，比如液晶的数据端总线接的P1，现在想改到P0，那么只需要修改宏定义这里就可以了，编译器编译的时候，会自动的把定义的名替换成实际的名称。

, Y/ p" b+ v6 R9 ]函数和宏的区别就在于，宏占用了大量的空间，而函数占用了时间。大家要知道的是，函数调用是要使用系统的栈来保存数据的，如果编译器 里有栈检查选 项，一般在函数的头会嵌入一些汇编语句对当前栈进行检查；同时，CPU也要在函数调用时保存和恢复当前的现场，进行压栈和弹栈操作，所以，函数调用需要一 些CPU时间。而宏不存在这个问题。宏仅仅作为预先写好的代码嵌入到当前程序，不会产生函数调用，所以仅仅是占用了空间，在频繁调用同一个宏的时候，该现象尤其突出。

# e7 y2 ?/ j/ {. U4 Z+ J举例如下：
$ J7 o) O: Y7 W
% H6 I- [9 n* R6 R* h3 J& W方法A：

1. 
   
2. #define bwMCDR2_ADDRESS 4
   : M! c# Y- i, [6 ~
3. #define bsMCDR2_ADDRESS 17
   5 _5 B1 ^# L0 m: E. r6 A" ]
4. int BIT_MASK(int __bf)
   3 I6 N5 p* t, W7 z) F
5. {
   5 }; w4 P' v; D& c4 Y0 [1 W& @
6. return ((1U << (bw ## __bf)) - 1)<< (bs ## __bf);
   7 e8 U% W8 g# h9 b
7. }
   
8. void SET_BITS(int __dst,
   
9. int __bf, int __val)
   
10. {
    % o/ |  A4 d- e5 s
11. __dst = ((__dst) & ~(BIT_MASK(__bf))) |
    " H3 T- ]; R* K5 k# {* {
12. /
    ' m! ?' f' M1 a9 X
13. (((__val) << (bs ## __bf))
    
14. & (BIT_MASK(__bf))))
    9 [& J- b5 @- [
15. }
    
16. SET_BITS(MCDR2, MCDR2_ADDRESS,ReGISterNumber);

复制代码

7 ~# {3 D7 L! ^1 p方法B：

1. 
   
2. #define bwMCDR2_ADDRESS 4
   ! Z* L* T" N! M' i- u- m
3. #define bsMCDR2_ADDRESS 17
   
4. #define bmMCDR2_ADDRESS BIT_MASK(MCDR2_ADDRESS)
   
5. #define BIT_MASK(__bf)
   # _1 g; ~8 S% Q) E4 v% x/ R" Q
6. (((1U << (bw ## __bf)) - 1)
   
7. << (bs ## __bf))
   
8. #define SET_BITS(__dst, __bf, __val)
   * }( n. H0 r) P2 X
9. /
   
10. ((__dst) = ((__dst) & ~(BIT_MASK(__bf)))
    
11. | /
    
12. (((__val) << (bs ## __bf))
    1 K! {- U# c% f, f% P- d" f" @
13. & (BIT_MASK(__bf))))
    
14. SET_BITS(MCDR2, MCDR2_ADDRESS,
    
15. RegisterNumber);

复制代码

B方法是我看到的最好的置位操作函数，是ARM公司源码的一部分，在短短的三行内实现了很多功能，几乎涵盖了所有的位操作功能。A方法是其变体，其中滋味还需大家仔细体会。
' T; E: {' b& }5 O9 [

4、以空间换取时间
+ G1 i: C7 |3 ?" c程序的复杂度包含时间复杂度和空间复杂度，而随着计算机硬件的发展，渐渐放低了对空间复杂度的要求，在很多情况下，为了换取程序的执行效率，牺牲计算机的空间。比如字符串的相关操作、使用缓存技术等。

计算机程序中最大的矛盾是空间和时间的矛盾，那么，从这个角度出发逆向思维来考虑程序的效率问题，我们就有了解决问题的第1招--以空间换时间。比如说字符串的赋值：

方法A：通常的办法
8 h/ I9 G( V* [- X9 r/ C

1. 
   * R8 z" I( Y8 y$ M' T7 c# R  e
2. #define LEN 32
   5 P, N$ i# V4 ?; j
3. char string1 [LEN];
   
4. memset (string1,0,LEN);
   
5. strcpy (string1,"This is a example!!"）;
   

复制代码

4 v0 {. u$ J3 V: H1 x方法B：
7 ~6 |" z3 i, ]% X5 v# t  @3 Y$ c

1. 
   + s5 G# G; V' Z$ Y- t# c# _: I
2. const char string2[LEN] ="This is a example!";
   " O+ s& b$ Y& B& S  r: |' F9 Z
3. char * cp;
   ) O4 n# J" p0 F  f7 Z
4. cp = string2 ;

复制代码

& N' @0 I7 j3 M使用的时候可以直接用指针来操作。

从上面的例子可以看出，A和B的效率是不能比的。在同样的存储空间下，B直接使用指针就可以操作了，而A需要调用两个字符函数才能完成。B的缺点在于灵活性没有A好。在需要频繁更改一个字符串内容的时候，A具有更好的灵活性；如果采用方法B，则需要预存许多字符串，虽然占用了大量的内存，但是获得了程序执行 的高效率。

如果系统的实时性要求很高，内存还有一些，那我推荐你使用该招数。

5、选择合适的算法和数据结构
- G, i/ C6 S% i2 p# F  {应该熟悉算法语言，知道各种算法的优缺点，具体资料请参见相应的参考资料，有很多计算机书籍上都有介绍。将比较慢的顺序查找法用较快的二分查找或乱序查找法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大提高程序执行的效率。
选择一种合适的数据结构也很重要。指针是一个包含地址的变量，可对他指向的变量进行寻址。使用指针可以很容易的从一个变量移到下一个变量，故特别适合对大量变量进行操作的场合。数组与指针语句具有十分密切的关系，一般来说，指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。但是在Keil中则相反，使用数组比使用的指针生成的代码更短。
; Z$ d/ Y0 z6 ^1 \& F; a6、使用条件编译
一般情况下对C语言程序进行编译时，所有的程序都参加编译，但是有时希望对其中一部分内容只在满足一定条件才编译，这就是条件编译。条件编译可以根据实际情况，选择不同的编译范围，从而产生不同的代码。
2 z" e, m9 e3 w; R7 j7、嵌入汇编——杀手锏译
' R8 n6 U9 G% r8 q. m0 Y4 j& ]汇编语言是效率最高的计算机语言，在一般项目开发当中一般都采用C语言来开发的，因为嵌入汇编之后会影响平台的移植性和可读性，不同平台的汇编指令是不兼容的。但是对于一些执着的程序员要求程序获得极致的运行的效率，他们都在C语言中嵌入汇编，即“混合编程”。

1. 
   
2. /*实现了a=a+b+c*/
   
3. __asm  
   
4. {  
   
5.     push eax  
   
6.     mov eax,a  
   
7.     add eax,b  
   
8.     add eax,c  
   
9.     mov a,eax  
   
10.     pop eax  
    
11. }

复制代码

手动编写汇编。在嵌入式软件开发中，一些软件模块最好用汇编语言来写，这可以使程序更加有效。虽然C/C++编译器对代码进行了优化，但是适当的使用内联汇编指令可以有效的提高整个系统运行的效率。
在熟悉汇编语言的人眼里，C语言编写的程序都是垃圾"。这种说法虽然偏激了一些，但是却有它的道理。汇编语言是效率最高的计算机语言，但是，不可能靠着它 来写一个操作系统吧?所以，为了获得程序的高效率，我们只好采用变通的方法--嵌入汇编，混合编程。嵌入式C程序中主要使用在线汇编，即在C程序中直接插 入_asm{ }内嵌汇编语句。
举例如下，将数组一赋值给数组二,要求每一字节都相符。
char string1[1024],string2[1024];

" R) q$ P' @2 z7 u方法A：
& q" x- ?" D; b

1. 
   % K. s/ ^% a! A& E$ ]3 Y
2. int I;
   
3. for (I =0 ;I<1024;I++)
   
4. *(string2 + I) = *(string1 + I)

复制代码

  h5 k+ }' Y, S* X/ e5 ~方法B：
* M' Z) E7 G$ q4 b: c' ]* P

1. 
   0 W8 F1 ~# y. b1 r. V7 B
2. #ifdef _PC_
   / u) c$ r. I; z7 ~  h. A
3. int I;
   
4. for (I =0 ;I<1024;I++)
   
5. *(string2 + I) = *(string1 + I);
   5 N$ y: e$ s# g5 c0 h
6. #else
   ( U, S& _! u1 H. `
7. #ifdef _ARM_
   - f7 k! q/ t: `8 H$ |& x& B6 t0 h
8. __asm
   ! t5 S4 I1 {+ G7 J
9. {
   
10. MOV R0,string1
    
11. MOV R1,string2
    
12. MOV R2,#0
    
13. loop:
    ; @* @3 w; b& s; w
14. LDMIA R0!, [R3-R11]
    ) l7 t: a% \# t2 `4 I' b' g. |1 y
15. STMIA R1!, [R3-R11]
    $ ]0 n" Y  ~* L9 U6 \0 Z# L
16. ADD R2,R2,#8
    + j$ L. e! Q/ s
17. CMP R2, #400
    
18. BNE loop
    , d8 S! {" j) o" J
19. }
    
20. #endif

复制代码

再举个例子：

1. 
   1 ]7 r) b% _- ~9 V
2. /* 把两个输入参数的值相加，结果存放到另外一个全局变量中 */
   
3. int result;
   
4. void Add(long a, long *b)
   
5. {
   1 s5 C& a4 b1 P5 s+ `: ^
6. _asm
   & p' w9 R) g6 `. Y5 G
7. {
   ! \; l( O0 U8 _' F" p% r9 u2 G$ r
8. MOV AX, a
   
9. MOV BX, b
   
10. ADD AX, [BX]
    
11. MOV result, AX
    1 L$ W& Z5 O0 N! |
12. }
    
13. }

复制代码

方法A是最常见的方法，使用了1024次循环；方法J则根据平台不同做了区分，在ARM平台下，用嵌入汇编仅用128次循环就完成了同样的操作。这里有朋友 会说，为什么不用标准的内存拷贝函数呢?这是因为在源数据里可能含有数据为0的字节，这样的话，标准库函数会提前结束而不会完成我们要求的操作。这个例程 典型应用于LCD数据的拷贝过程。根据不同的CPU，熟练使用相应的嵌入汇编，可以大大提高程序执行的效率。

1 O, I2 w+ l5 s0 I6 o& ^* E虽然是必杀技，但是如果轻易使用会付出惨重的代价。这是因为，使用了嵌入汇编，便限制了程序的可移植性，使程序在不同平台移植的过程中，卧虎藏龙，险象环生！同时该招数也与现代软件工程的思想相违背，只有在迫不得已的情况下才可以采用。

; P/ i, V# \- Q8、避免使用标准库例程
5 F6 x+ _/ ^' k: ?& c嵌入式系统编程应避免使用标准库例程，因为很多大的库例程设法处理所有可能的情况，所以占用了庞大的内存空间，因而应尽可能地减少使用标准库例程。
2 [1 [" P8 e9 y. S. ?/ J
6 J8 ]( @2 ^& E; `5 [( u; p- w- O* q

9、确保声明和定义是静态的，除非您希望从不同的文件中调用该函数。
+ {3 {% L; m; f  N" \6 N" \/ G" W
: F; Y$ |2 c5 _! {) q% O+ D$ b在同一文件函数对其他函数可见，才称之为静态函数。它限制其他访问内部函数，如果我们希望从外界隐藏该函数。现在我们并不需要为内部函数创建头文件，其他看不到该函数。静态声明一个函数的优点包括：

（1）两个或两个以上具有相同名称的静态函数，可用于在不同的文件。
& W8 L" q% r6 l1 ~; [（2）编译消耗减少，因为没有外部符号处理。

10、数学方法解决问题
" T6 T/ E+ [9 U0 N/ ~
现在我们演绎高效C语言编写的第二招--采用数学方法来解决问题。数学是计算机之母，没有数学的依据和基础，就没有计算机的发展，所以在编写程序的时候，采用一些数学方法会对程序的执行效率有数量级的提高。举例如下，求 1~100的和。

方法A：
4 \  m# M2 ]0 l% m

1. 
   - @5 A5 I8 t* P, `+ S
2. int I , j;
   % n, g* g( H% y' Q
3. for (I = 1 ;I<=100; I ++）
   / w, [! p( T3 `3 K, a% m- Y9 M- P
4. {
   
5. j += I;
   ) n  \0 o4 h  B/ x4 Z/ \
6. }

复制代码

1 f5 k* x3 p$ j- z' {( O

方法B：

1. 
   
2. int I;
     g5 |4 I& a1 w6 @8 W6 U" ^, J
3. I = (100 * (1+100)) / 2

复制代码

" C* Y. c& K: v/ Y. J2 I0 _& D# q3 X

这个例子是我印象最深的一个数学用例，是我的计算机启蒙老师考我的。当时我只有小学三年级，可惜我当时不知道用公式 N×（N+1）/ 2 来解决这个问题。方法E循环了100次才解决问题，也就是说最少用了100个赋值，100个判断，200个加法（I和j）；而方法F仅仅用了1个加法，1次乘法，1次除法。效果自然不言而喻。所以，现在我在编程序的时候，更多的是动脑筋找规律，最大限度地发挥数学的威力来提高程序运行的效率。
8 w2 g9 I& _# d( x" i+ Y% m2 Z
# O* r+ Z/ D! {. F11、使用位操作

" v" M9 j! _) I' z2 K3 |使用位操作。减少除法和取模的运算。在计算机程序中数据的位是可以操作的最小数据单位，理论上可以用"位运算"来完成所有的运算和操作。一般的位操作是用来控制硬件的，或者做数据变换使用，但是，灵活的位操作可以有效地提高程序运行的效率。举例如下：
  ~. F) n* l. V
* z+ L8 G7 t9 T1 k0 q3 q5 f% g8 i方法A：

1. 
   
2. int I,J;
   
3. I = 257 /8;
   - X) B: e3 A# D
4. J = 456 % 32;

复制代码

: S% v- |7 Z6 V7 f

方法B：
& o! M+ F, O5 f' E' k, b

1. 
   
2. int I,J;
   
3. I = 257 >>3;
   - C8 f- k/ c! H/ \) n# ^4 o, K
4. J = 456 - (456 >> 4 << 4);

复制代码

! W" X, d) L5 G. p1 k; h在字面上好像B比A麻烦了好多，但是，仔细查看产生的汇编代码就会明白，方法B调用了基本的取模函数和除法函数，既有函数调用，还有很多汇编代码和寄存器参 与运算；而方法H则仅仅是几句相关的汇编，代码更简洁，效率更高。当然，由于编译器的不同，可能效率的差距不大，但是，以我目前遇到的MS C ,ARM C 来看，效率的差距还是不小。

+ j0 h; r5 v- j* ^0 [3 b对于以2的指数次方为"*"、"/"或"%"因子的数学运算，转化为移位运算"<< >>"通常可以提高算法效率。因为乘除运算指令周期通常比移位运算大。
' q" b  f3 t& L% Q& F" d
. Z) Z1 K' {0 [; F" y9 `C语言位运算除了可以提高运算效率外，在嵌入式系统的编程中，它的另一个最典型的应用，而且十分广泛地正在被使用着的是位间的与（&）、或 （|）、非（~）操作，这跟嵌入式系统的编程特点有很大关系。我们通常要对硬件寄存器进行位设置，譬如，我们通过将AM186ER型80186处理器的中 断屏蔽控制寄存器的第低6位设置为0（开中断2），最通用的做法是：
) |  {* K, d( `8 X2 n& ~

1. 
   1 Q; c' q( a* K" P3 B8 y
2. #define INT_I2_MASK 0x0040
   
3. wTemp = inword(INT_MASK);
   * A0 I9 Q- o# Y: f1 K! g
4. outword(INT_MASK, wTemp &~INT_I2_MASK);

复制代码

' s! b/ i' ?# e3 [' x8 x

  p+ Y1 s6 a2 ^$ \( x/ p而将该位设置为1的做法是：

1. 
   1 u2 N, d+ U0 t) o+ e; A
2. #define INT_I2_MASK 0x0040
   - ?4 q" F4 N3 O0 [8 s0 Z
3. wTemp = inword(INT_MASK);
   # {9 b) R2 v& q* _! B
4. outword(INT_MASK, wTemp | INT_I2_MASK);  

复制代码

. P6 N+ t+ d& t9 T. O; L

判断该位是否为1的做法是：
3 [9 f4 v( R, `6 m

1. 
   
2. #define INT_I2_MASK 0x0040
   
3. wTemp = inword(INT_MASK);
   ' v: g0 E3 b5 ]
4. if(wTemp & INT_I2_MASK)
   & H# {. E& F. l# M4 B
5. {
   $ V5 q9 O) G* m0 `, j& n
6. … /* 该位为1 */
   
7. }

复制代码

( o' l9 y* X" S' W

运用这招需要注意的是，因为CPU的不同而产生的问题。比如说，在PC上用这招编写的程序，并在PC上调试通过，在移植到一个16位机平台上的时候，可能会产生代码隐患。所以只有在一定技术进阶的基础下才可以使用这招。
  c1 V) Z5 s% B; M
- S- J/ k. Q4 E12、利用硬件特性

* z3 j$ [5 I; {  D首先要明白CPU对各种存储器的访问速度，基本上是：

CPU内部RAM　>　外部同步RAM　>　外部异步RAM　>　FLASH/ROM

对于程序代码，已经被烧录在FLASH或ROM中，我们可以让CPU直接从其中读取代码执行，但通常这不是一个好办法，我们最好在系统启动后将FLASH或ROM中的目标代码拷贝入RAM中后再执行以提高取指令速度；

% z4 Z  @/ o" R2 Z, m8 p对于UART等设备，其内部有一定容量的接收BUFFER，我们应尽量在BUFFER被占满后再向CPU提出中断。例如计算机终端在向目标机通过RS-232传递数据时，不宜设置UART只接收到一个BYTE就向CPU提中断，从而无谓浪费中断处理时间；
( |' {+ O5 v$ R% y1 v5 J
如果对某设备能采取DMA方式读取，就采用DMA读取，DMA读取方式在读取目标中包含的存储信息较大时效率较高，其数据传输的基本单位是块，而所传输 的数据是从设备直接送入内存的（或者相反）。DMA方式较之中断驱动方式，减少了CPU 对外设的干预，进一步提高了CPU与外设的并行操作程度。

13、使用寄存器变量

当对一个变量频繁被读写时，需要反复访问内存，从而花费大量的存取时间。为此，C语言提供了一种变量，即寄存器变量。这种变量存放在CPU的寄存器中，使 用时，不需要访问内存，而直接从寄存器中读写，从而提高效率。寄存器变量的说明符是register。对于循环次数较多的循环控制变量及循环体内反复使用 的变量均可定义为寄存器变量，而循环计数是应用寄存器变量的最好候选者。
- e; O8 p* J: [
$ q7 x6 ^1 e  B1 N( C(1) 只有局部自动变量和形参才可以定义为寄存器变量。因为寄存器变量属于动态存储方式，凡需要采用静态存储方式的量都不能定义为寄存器变量，包括：模块间全局变量、模块内全局变量、局部static变量；

0 Q" i8 G5 a* N  G6 S/ Y( e2 c6 }(2) register是一个"建议"型关键字，意指程序建议该变量放在寄存器中，但最终该变量可能因为条件不满足并未成为寄存器变量，而是被放在了存储器中，但编译器中并不报错（在C++语言中有另一个"建议"型关键字：inline）。
' H% W0 y' J8 j
3 R, W1 q" I# V( L' V下面是一个采用寄存器变量的例子：
& l+ H. L3 A$ v' _

1. 
   & w! c6 x8 s% ~" M
2. /* 求1+2+3+….+n的值 */
   + O5 B' v8 z+ {( t4 D
3. WORD Addition(BYTE n)
   # O# U/ }  S/ {
4. {
   
5. register i,s=0;
   7 k0 Y& _7 `: O  d# j9 f
6. for(i=1;i<=n;i++)
   
7. {
   
8. s=s+i;
   
9. }
   * U9 p& B1 Y# O# k9 w
10. return s;
    
11. }

复制代码

0 W) D( T  G2 s; ~4 g' e- q

1 a! D2 E" i" g# O$ m9 A本程序循环n次，i和s都被频繁使用，因此可定义为寄存器变量。

03

保障C代码执行效率的优化方法

. w( u5 I3 F/ m% c1、使用尽量小的数据类型
- D- R% i; H: `& v5 {- S1 a! U比如某个变量的值范围是0~255，那么就定义成unsignedchar，当然也可以定义成unsignedint，但是这样造成了内存的浪费，而且运算时效率要低一点。
如果数据没有负数的话，尽量定义成无符号的类型。应尽量避免定义成浮点型数据类型或双精度（占8个字节）类型，这两种类型运算时很消耗CPU资源。
* N& j* w' |, F; O2 g9 i/ n; r, C7 }4 G比如采集电压范围是0-5v，精确到小数点后三位，可以把采集到的数据扩大1000倍，即使最大也才到5000，然后多采集几次做个滤波算法，最后电压算出来后只需要在第一位后面加个小数点就可以了，变量定义成unsignedint型变量就没问题了。
" B. y1 B" v* v- D& j# k5 k/ J, A/ k) n2、尽量避免调用延时函数
3 d3 p2 b* v) O* ?' D; {& m没有带操作系统的程序只能在while(1)里面循环执行，如果在这里面调用大量的延时这样会很消耗CPU的资源，延时等于是让它在这歇着不干事了，只有中断里面的才会执行。如果仅仅是做一个LED一秒闪烁一次的程序，那么很简单，可以直接调用延时函数，但是实际的项目中往往在大循环里有很多事要做，对于实时性要求较高的场合就不行了。
1 l( N. V; N- v! ^" I为了避免使用延时，可以使用定时器中断产生一个标志位，到了时间标志位置1，在主程序里面只需要检测标志位，置1了才执行一次，然后清标志。其他时间就去做别的事了，而不会在这等待了。
" v' d3 a2 E$ ?最好的例子就是数码管的显示，使用中断调显示。然后是按键检测，一般的程序都是做的while(!key)等待按键释放，如果按键一直按着，那后面的程序就永远得不到运行死在这了，其实可以做一个按键标志检测下降沿和上升沿就可以避免这个问题了。

6 c, f) _( y/ c1 Z) Z5 A/ l4 k

3、避免使用乘除法
: [: u% U0 ]5 [* ]' z乘除法很消耗CPU资源，查看汇编代码会发现，一个乘除法运算会编译出10几甚至几10行代码。如果是乘以或除以2的n次方，可以用<<或>>来实现，这种移位运算在编译时就已经算好了，所以代码很简洁，运算效率就高。但是需要特别注意运算符的优先级问题。
4、尽量使用复合赋值运算符
a=a+b与a+=b这两个表达式有什么区别呢？
3 K' b$ L: i. v6 u前者是先计算a+b的值，然后保存到ACC寄存器，再把ACC寄存器的值赋给a。而后者是直接将a+b的值赋给a，节省一个步骤。虽然只节省了一条指令，但是当这个运算循环几千次几万次呢？那么效果很明显了。
像其他的-=、*=、/=、%=等都是一样的。
! m% F( w( _- y: J5、不定义不使用的返回值。
0 h+ O& @/ q6 e, R8 k" |
function函数定义并不知道函数返回值是否被使用，假如返回值从来不会被用到，应该使用void来明确声明函数不返回任何值。

6、在一个逻辑条件语句中常数项永远在左侧。

1. 
   
2. int  x = 4; if （x = 1）
   
3. {
   
4. x = x + 2;
   
5. printf（"%d",x）；// Output is 3 }
   
6. int  x = 4;
   9 p9 x4 @! P1 [% k' }
7. if （1 = x）
   
8. {
   . ~0 a2 h& J1 K8 O- A4 S+ I
9. x = x + 2;
   * o( K* o! U/ g$ |8 e
10. printf（"%d",x）；// Compilation error
    ' N2 `! J! p9 B8 ]8 L0 K$ S- Q
11. }

复制代码

( ]% h- f  s( t6 x1 A' R7、减少运算的强度
（1）、查表(游戏程序员必修课)
+ F2 c  h3 N2 v3 Q/ A# g一个聪明的游戏大虾，基本上不会在自己的主循环里搞什么运算工作，绝对是先计算好了，再到循环里查表。看下面的例子：

旧代码：
% k% f( u4 h7 Y  p! n0 A

1. 
   
2.     long factorial(int i)
   
3.     {
   
4.         if (i == 0)
   ! Z- n7 E+ ^! Y. j/ y( A0 c
5.             return 1;
   0 Z2 A$ b. v/ O( d, s9 o# l
6.         else
   8 k  U) j( c1 b! n* u7 w: {0 o
7.             return i * factorial(i - 1);
   % T5 F6 B- A% A% I; Q
8.     }
   ; `  G7 W$ `* q4 }
9. 新代码：
   " A& F/ I" I/ F+ e: |; p9 N
10.     static long factorial_table[] =
    
11.         {1， 1， 2， 6， 24， 120， 720  /* etc */ };
    # t% k6 e5 N  @  K$ Z: |
12.     long factorial(int i)
      \& l* L( |. g+ d  m* o+ d
13.     {
    
14.         return factorial_table[i];
    ) v: S3 {7 q. u. s
15.     }

复制代码

+ L6 M% Y6 B  D$ j. i5 b7 v

如果表很大，不好写，就写一个init函数，在循环外临时生成表格。
  l- m2 V! e8 l" |! O（2）、求余运算
. ]5 u3 {6 c3 l3 za=a%8;
可以改为：
a=a&7;

说明：位操作只需一个指令周期即可完成，而大部分的C编译器的“%”运算均是调用子程序来完成，代码长、执行速度慢。通常，只要求是求2n方的余数，均可使用位操作的方法来代替。
（3）、平方运算
3 |( C- t5 J0 B- S, n; |2 Ua=pow(a, 2.0);
可以改为：
9 _. }0 o" O6 e0 s$ L) ]0 Ua=a*a;
  B& C' l9 w/ t6 q说明：在有内置硬件乘法器的单片机中(如51系列)，乘法运算比求平方运算快得多，因为浮点数的求平方是通过调用子程序来实现的，在自带硬件乘法器的AVR单片机中，如ATMega163中，乘法运算只需2个时钟周期就可以完成。既使是在没有内置硬件乘法器的AVR单片机中，乘法运算的子程序比平方运算的子程序代码短，执行速度快。
2 T5 _* q" C8 [) F+ n" `如果是求3次方，如：
a=pow(a，3。0);
& ]# e. n- }  M1 V& J/ Q  N: x更改为：
( S: y7 f, }* m) o2 ?) T2 va=a*a*a；
/ R7 \" {  O, f- o2 ^6 D则效率的改善更明显。
& S" P6 X3 M6 V（4）、用移位实现乘除法运算
a=a*4;b=b/4;
可以改为：
a=a<<2;b=b>>2;
通常如果需要乘以或除以2n，都可以用移位的方法代替。在ICCAVR中，如果乘以2n，都可以生成左移的代码，而乘以其它的整数或除以任何数，均调用乘除法子程序。用移位的方法得到代码比调用乘除法子程序生成的代码效率高。实际上，只要是乘以或除以一个整数，均可以用移位的方法得到结果，如：
5 H9 I, B8 m% y8 g3 }a=a*9
可以改为：
; k: v+ ?, l  za=(a<<3)+a
9 |6 l" _, ]: P) l* Y6 }采用运算量更小的表达式替换原来的表达式，下面是一个经典例子:
旧代码:

1. 
   
2.     x = w % 8;
   
3.     y = pow(x， 2.0);
   % @8 O* l% r, b' {& s4 s8 z
4.     z = y * 33;
   
5.     for (i = 0;i < MAX;i++)
   ' y0 J. }4 X+ j" \
6.     {
   6 u$ y4 b; E& s* y
7.         h = 14 * i;
   5 q4 ?' Y! s3 x' I
8.         printf("%d"， h);
   ) a; r) s6 T) S- q
9.     }
   " Q$ I) H0 ]! t9 x2 v1 l
10. 新代码:
    2 i$ P! \3 ^4 n9 ~8 y; l
11.     x = w & 7;              /* 位操作比求余运算快 */
    ( C, K) }" Y- I7 y
12.     y = x * x;               /* 乘法比平方运算快 */
    - Q5 j% G/ T: z9 s) ]: f; w
13.     z = (y << 5) + y;          /* 位移乘法比乘法快 */
    
14.     for (i = h = 0; i < MAX; i++)
    
15.     {
    
16.         h += 14;                /* 加法比乘法快 */
    
17.         printf("%d"， h);
    & @9 G% X- o- r- v; a4 ~- b0 Q5 Q
18. }

复制代码

（5）、避免不必要的整数除法
整数除法是整数运算中最慢的，所以应该尽可能避免。一种可能减少整数除法的地方是连除，这里除法可以由乘法代替。这个替换的副作用是有可能在算乘积时会溢出，所以只能在一定范围的除法中使用。
不好的代码：int i， j， k， m；m = i / j / k；
% n- `5 a! c5 o! @; |推荐的代码：int i， j， k， m；m = i / (j * k)；
: ]  Q6 V2 O- [0 R; U* P（6）、使用增量和减量操作符
在使用到加一和减一操作时尽量使用增量和减量操作符，因为增量符语句比赋值语句更快，原因在于对大多数CPU来说，对内存字的增、减量操作不必明显地使用取内存和写内存的指令，比如下面这条语句：x=x+1;
: @8 K* |' O" s( G1 C模仿大多数微机汇编语言为例，产生的代码类似于：
move A，x      ;把x从内存取出存入累加器Aadd A，1        ;累加器A加1store x          ;把新值存回x
  R) x+ A, Z5 {# |/ H7 X; {' S如果使用增量操作符，生成的代码如下：
, R5 V! [6 a8 gincr x           ;x加1
- x8 Q5 d! I8 M# |6 J% @% @显然，不用取指令和存指令，增、减量操作执行的速度加快，同时长度也缩短了。
（7）、使用复合赋值表达式
, R/ [! k! k5 u3 I3 e3 g  ]复合赋值表达式(如a-=1及a+=1等)都能够生成高质量的程序代码。
（8）、提取公共的子表达式
; r3 x5 n7 k6 V7 r1 p: T* }. |  [在某些情况下，C++编译器不能从浮点表达式中提出公共的子表达式，因为这意味着相当于对表达式重新排序。需要特别指出的是，编译器在提取公共子表达式前不能按照代数的等价关系重新安排表达式。这时，程序员要手动地提出公共的子表达式（在VC.NET里有一项“全局优化”选项可以完成此工作，但效果就不得而知了）。
; Z1 o+ a/ j/ O4 t5 c不好的代码：
$ g9 D& G" ~& i9 @1 Z

1. 
   - d3 T. E$ d7 X
2. float a， b， c， d， e， f；
   
3. 。。。
   
4. e = b * c / d；
   
5. f = b / d * a；

复制代码

推荐的代码：

1. 
   
2. float a， b， c， d， e， f；
   - X2 g$ o' M  A3 l( v
3. 。。。
   3 a0 [# L+ U$ M, t+ W1 l' B! X
4. const float t(b / d)；
   
5. e = c * t；
   
6. f = a * t；

复制代码

- B# F* ]4 b* X7 e不好的代码：

1. 
   
2. float a， b， c， e， f；
   
3. 。。。
   + `4 O9 l0 F" t
4. e = a / c；
   0 F* m- c0 h* P* o
5. f = b / c；

复制代码

; W' a+ E$ `1 v% w; ~' k

, z+ O5 O3 C/ X3 H6 d5 W+ X$ [

推荐的代码：

1. 
   1 m* N) I7 G3 D1 B1 q" O0 H
2. float a， b， c， e， f；
   
3. 。。。
   
4. const float t(1.0f / c)；
     B8 d9 x2 ?! K% B' Q
5. e = a * t；
   + R( j5 k( b/ A1 s- I' m7 Q# d1 x
6. f = b * t；

复制代码

( @( R# A" r! C5 \: @. \

8、结构体成员的布局
很多编译器有“使结构体字，双字或四字对齐”的选项。但是，还是需要改善结构体成员的对齐，有些编译器可能分配给结构体成员空间的顺序与他们声明的不同。但是，有些编译器并不提供这些功能，或者效果不好。所以，要在付出最少代价的情况下实现最好的结构体和结构体成员对齐，建议采取下列方法：
（1）按数据类型的长度排序
把结构体的成员按照它们的类型长度排序，声明成员时把长的类型放在短的前面。编译器要求把长型数据类型存放在偶数地址边界。在申明一个复杂的数据类型 (既有多字节数据又有单字节数据) 时，应该首先存放多字节数据，然后再存放单字节数据，这样可以避免内存的空洞。编译器自动地把结构的实例对齐在内存的偶数边界。
（2）把结构体填充成最长类型长度的整倍数
把结构体填充成最长类型长度的整倍数。照这样，如果结构体的第一个成员对齐了，所有整个结构体自然也就对齐了。下面的例子演示了如何对结构体成员进行重新排序：
不好的代码，普通顺序：
. T1 `6 D+ t$ C' [/ Z0 U

1. 
   ' _+ U, J/ D! f; ~. `1 q) o
2. struct
   0 w4 Q, j9 H8 U/ K  ]: G
3. {
   / J' M+ o7 {( D) ?
4. 　　                           char a[5]；
   - T, U7 ]  a9 p, g5 h1 N) \; i
5. 　　       long k；
   9 v- L+ y1 R9 T+ \+ W
6. 　 double x；
   / B5 o# W, {; X# i8 T1 I6 C
7. } baz；

复制代码

1 \# e' U- E- M9 s9 G  g% h. [1 }推荐的代码，新的顺序并手动填充了几个字节：
3 @  |: n4 X: w. f& D5 }, q

1. 
   # @  s6 v" a& G8 E# {$ c5 e0 r
2. struct
   * _  H" @' c- Z9 z2 r
3. {
   8 X6 i! b- x  @" ^
4. 　　                           double x；
   ( e. I6 Q3 C. r+ D
5. 　　                           long k；
   4 i' _- W) R. F- v+ T
6. 　　                           char a[5]；
   ' S# G1 k* N- \% Q
7. char pad[7]；
   
8. } baz；

复制代码

4 u/ X- a, C" p% C# a4 c) `. L这个规则同样适用于类的成员的布局。
（3）按数据类型的长度排序本地变量
当编译器分配给本地变量空间时，它们的顺序和它们在源代码中声明的顺序一样，和上一条规则一样，应该把长的变量放在短的变量前面。如果第一个变量对齐了，其它变量就会连续的存放，而且不用填充字节自然就会对齐。有些编译器在分配变量时不会自动改变变量顺序，有些编译器不能产生4字节对齐的栈，所以4字节可能不对齐。下面这个例子演示了本地变量声明的重新排序：
不好的代码，普通顺序
) k" n7 b1 `+ d4 s# C7 C

1. 
   
2. short ga， gu， gi；
   
3. long foo， bar；
   
4. double x， y， z[3]；
   ! B% U3 G6 B# s: x! D
5. char a， b；
   + [3 L: |) s4 J9 J
6. float baz；
   * X7 m7 I( l1 F$ x$ a5 u
7. 推荐的代码，改进的顺序
   
8. double z[3]；
   & \) J4 s) S" m' `' Q2 D, x( P1 N
9. double x， y；
   
10. long foo， bar；
    
11. float baz；
    0 |0 J& b/ s+ ]2 N4 I4 c
12. short ga， gu， gi；

复制代码

* ~- k% X) _3 T, |1 ~

0 q  r; q7 ]; u& i, O0 }+ K) A) ]$ g（4）把频繁使用的指针型参数拷贝到本地变量
避免在函数中频繁使用指针型参数指向的值。因为编译器不知道指针之间是否存在冲突，所以指针型参数往往不能被编译器优化。这样数据不能被存放在寄存器中，而且明显地占用了内存带宽。注意，很多编译器有“假设不冲突”优化开关（在VC里必须手动添加编译器命令行/Oa或/Ow），这允许编译器假设两个不同的指针总是有不同的内容，这样就不用把指针型参数保存到本地变量。否则，请在函数一开始把指针指向的数据保存到本地变量。如果需要的话，在函数结束前拷贝回去。
不好的代码：
# P7 G7 C4 A. m" Q, O$ e+ n( v4 Y

1. 
   
2. // 假设 q != r
   
3. void isqrt(unsigned long a， unsigned long* q， unsigned long* r)
   
4. {
   
5. 　　*q = a；
   
6. 　　if (a > 0)
   
7. 　　{
   
8. 　　　　while (*q > (*r = a / *q))
   
9. 　　　　{
   + `! l; [+ @# D9 w( {' h9 u( G
10. 　　　　　　*q = (*q + *r) >> 1；
    
11. 　　　　}
    / R- O  ^0 ~( P1 g5 e6 |# @5 @* i
12. 　　}
    , v( v4 z; r8 E7 j: u; ^: y
13. 　　*r = a - *q * *q；
    
14. }

复制代码

. p; j4 f: h4 Q1 n# O; X

推荐的代码：
5 ?, |2 M3 ^) A$ q* _" [& Z

1. 
   1 _& i) s7 c! O- |: o! ^' [
2. // 假设 q != r
   
3. void isqrt(unsigned long a， unsigned long* q， unsigned long* r)
   
4. {
   
5. 　　unsigned long qq， rr；
   
6. 　　qq = a；
   ( n4 K' N1 S! N2 c3 d
7. 　　if (a > 0)
   9 h; Z) g$ W* s! e7 o; K3 |
8. 　　{
   
9. 　　　　while (qq > (rr = a / qq))
   
10. 　　　　{
    ( {7 L+ _' O" |0 B4 r5 H- E' Y
11. 　　　　　　qq = (qq + rr) >> 1；
    5 Z7 l' O: w6 {( c/ D
12. 　　　　}
    4 i! S' R+ l# s$ p* I
13. 　　}
    
14. 　　rr = a - qq * qq；
    + X2 Z. m4 E  \9 F, a+ `1 M
15. 　　*q = qq；
    0 ]2 M! x5 a& r0 P% P- f
16. 　　*r = rr；
    : }3 e6 K, U% L
17. }

复制代码

5 d+ E7 R* N4 Z, m0 ]; A

9、循环优化
（1）、充分分解小的循环
要充分利用CPU的指令缓存，就要充分分解小的循环。特别是当循环体本身很小的时候，分解循环可以提高性能。注意:很多编译器并不能自动分解循环。不好的代码：

1. // 3D转化：把矢量 V 和 4x4 矩阵 M 相乘
   6 d! _+ X5 v9 y+ S/ C* B2 w. g
2. for (i = 0；i < 4；i ++)
   
3. {
   0 V) O' q4 O" ^/ a: }
4. 　　r[i] = 0；
   , ^$ n) q3 |! |# Z5 u: g. y& p* _
5. 　　for (j = 0；j < 4；j ++)
   
6. 　　{
   
7. 　　　　r[i] += M[j][i]*V[j]；
   ; }3 ]( Y: _6 j4 o$ b8 I* l
8. 　　}
   ; h3 T8 j  `0 `
9. }
   3 T) f' i3 k( v4 I$ J
10. 推荐的代码：

复制代码

1. r[0] = M[0][0]*V[0] + M[1][0]*V[1] + M[2][0]*V[2] + M[3][0]*V[3]；
   
2. r[1] = M[0][1]*V[0] + M[1][1]*V[1] + M[2][1]*V[2] + M[3][1]*V[3]；
   # r' D1 _1 k% P
3. r[2] = M[0][2]*V[0] + M[1][2]*V[1] + M[2][2]*V[2] + M[3][2]*V[3]；
   
4. r[3] = M[0][3]*V[0] + M[1][3]*V[1] + M[2][3]*V[2] + M[3][3]*v[3]；

复制代码

+ D# @& t1 t, P! X4 d) ~（2）、提取公共部分
7 {$ t- T2 D( e: l; s+ r: A对于一些不需要循环变量参加运算的任务可以把它们放到循环外面，这里的任务包括表达式、函数的调用、指针运算、数组访问等，应该将没有必要执行多次的操作全部集合在一起，放到一个init的初始化程序中进行。
3 U  y$ D8 G7 K7 w5 \( p  V（3）、延时函数
3 f1 N% k7 W* K) h' e) [1 G) G, K通常使用的延时函数均采用自加的形式：

1. 
   " A. c0 U6 E1 `6 {! D
2.     void delay (void)
   + M( d* I! |+ q. [
3. {
     }. Y/ W% W5 {. q$ R$ j+ D
4. unsigned int i;
   
5.     for (i=0;i<1000;i++) ;
   
6.     }

复制代码

' }' l8 z- n2 n$ b+ f将其改为自减延时函数：

1. 
   ; `( H0 F: |- D' b& E. `5 a' R2 ~
2.     void delay (void)
   - X/ _; K8 V, I5 U) T8 `3 F7 M
3. {
   
4. unsigned int i;
   
5.         for (i=1000;i>0;i--) ;
   
6.     }

复制代码

两个函数的延时效果相似，但几乎所有的C编译对后一种函数生成的代码均比前一种代码少1~3个字节，因为几乎所有的MCU均有为0转移的指令，采用后一种方式能够生成这类指令。在使用while循环时也一样，使用自减指令控制循环会比使用自加指令控制循环生成的代码更少1~3个字母。但是在循环中有通过循环变量“i”读写数组的指令时，使用预减循环有可能使数组超界，要引起注意。
（4）、while循环和do…while循环
用while循环时有以下两种循环形式：
3 a" ]* v! w% Z: s' ]( i

1. 
   1 m2 _' X1 t+ E4 R+ p
2. unsigned int i;
   - Q3 S! k3 F) ~$ B3 P' D
3.     i=0;
   
4.     while (i<1000)
   
5.     {
   
6.         i++;
   
7.            //用户程序
   
8.     }
   0 O0 M" i" V* I) M  {$ O

复制代码

; j! U1 ]/ O2 [9 P5 {

或：

1. 
   
2. unsigned int i;
   & k- P% h' c+ e1 v' K  I/ C
3.     i=1000;
   / U7 g, W( r- d+ M$ p2 C7 x$ Q
4. do
   
5. {
   
6.           i--;
   
7.           //用户程序
   
8. }
   
9. while (i>0);

复制代码

  _7 F" J1 p7 @% A; S1 m在这两种循环中，使用do…while循环编译后生成的代码的长度短于while循环。
（6）、循环展开
这是经典的速度优化，但许多编译程序(如gcc -funroll-loops)能自动完成这个事，所以现在你自己来优化这个显得效果不明显。
旧代码:

1. 
   + e0 `; t' w' T" f7 U# F$ l
2. for (i = 0; i < 100; i++)
   
3. {
   ' k' y5 Y& `. L: [
4. do_stuff(i);
   
5. }

复制代码

0 j9 |! A. _4 K- ^% U2 ]& _

新代码:
0 c3 v$ ~( }* Z3 b" D2 g

1. 
   ; N( S% B4 i  Z
2. for (i = 0; i < 100; )
   & O! Y' L% d: {  l+ i6 ~
3. {
   . L! q! X. x* n) M! W
4. do_stuff(i); i++;
   . a* I1 \! z: X7 q, J
5. do_stuff(i); i++;
   
6. do_stuff(i); i++;
   
7. do_stuff(i); i++;
   : J+ c/ Y- L# @$ P3 `
8. do_stuff(i); i++;
   + ?3 O# }: R2 A$ M0 _
9. do_stuff(i); i++;
   
10. do_stuff(i); i++;
    
11. do_stuff(i); i++;
    
12. do_stuff(i); i++;
    + j5 D, s& I; A2 o2 p' {
13. do_stuff(i); i++;
    ; ?4 w" Q& H, W+ C2 C. ]5 \
14. }

复制代码

可以看出，新代码里比较指令由100次降低为10次，循环时间节约了90%。不过注意:对于中间变量或结果被更改的循环，编译程序往往拒绝展开，(怕担责任呗)，这时候就需要你自己来做展开工作了。
& @& Y  O" e  L' L还有一点请注意，在有内部指令cache的CPU上(如MMX芯片)，因为循环展开的代码很大，往往cache溢出，这时展开的代码会频繁地在CPU 的cache和内存之间调来调去，又因为cache速度很高，所以此时循环展开反而会变慢。还有就是循环展开会影响矢量运算优化。
（6）、循环嵌套
; s4 [9 ~) K2 p7 c9 r把相关循环放到一个循环里，也会加快速度。
旧代码:

1. 
   5 y/ p3 N: g/ e) @5 R3 X- a" t9 s. Y
2. for (i = 0; i < MAX; i++)          /* initialize 2d array to 0's */
   1 X9 I2 }* }( E, |( T% @: d2 |  t7 L
3.     for (j = 0; j < MAX; j++)
   : A9 [6 i  S6 q8 _( k9 z
4.         a[i][j] = 0.0;
   
5.     for (i = 0; i < MAX; i++)        /* put 1's along the diagonal */
   1 d5 V  P4 O/ Y
6.         a[i][i] = 1.0;

复制代码

8 f3 D- K, }$ h! t( M9 C- Z

新代码:

1. 
   
2. for (i = 0; i < MAX; i++)          /* initialize 2d array to 0's */
   
3. {
   
4.     for (j = 0; j < MAX; j++)
   9 X# V6 ]3 p" {/ V( q8 B
5.         a[i][j] = 0.0;
   
6.     a[i][i] = 1.0;                            /* put 1's along the diagonal */
   $ @( _0 ]- h9 i  a9 S
7. }

复制代码

/ f9 q0 i! Z' F- c' m& p（7）、Switch语句中根据发生频率来进行case排序
' x  H4 n, l" z  ]- vSwitch 可能转化成多种不同算法的代码。其中最常见的是跳转表和比较链/树。当switch用比较链的方式转化时，编译器会产生if-else-if的嵌套代码，并按照顺序进行比较，匹配时就跳转到满足条件的语句执行。所以可以对case的值依照发生的可能性进行排序，把最有可能的放在第一位，这样可以提高性能。此外，在case中推荐使用小的连续的整数，因为在这种情况下，所有的编译器都可以把switch 转化成跳转表。
6 A. g4 e3 B) w' U  p  D( e- R1 ]! z不好的代码：
; H9 w0 P/ G: N6 U

1. 
   
2. int days_in_month， short_months， normal_months， long_months；
   
3. 。。。。。。
   # _0 a/ [0 Y& V: l6 u* e
4. switch (days_in_month)
   - r8 O/ U! B+ A8 F; L' _1 u
5. {
   
6. 　　case 28:
   , E3 U8 h; ]! f% m& n4 B, B
7. 　　case 29:
   - k% n9 t# x9 w+ E- o
8. 　　　　short_months ++；
   
9. 　　　　break；
   9 _1 R3 e5 _* [8 l
10. 　　case 30:
    
11. 　　　　normal_months ++；
    
12. 　　　　break；
    3 u2 |6 C! t  n8 g9 U
13. 　　case 31:
    / w6 \! Q* j* f  Z1 |  y
14. 　　　　long_months ++；
    + I9 Y! Z; _+ e9 K+ ?* E4 @
15. 　　　　break；
    
16. 　　default:
    
17. 　　　　cout << "month has fewer than 28 or more than 31 days" << endl；
    7 ?" F( b3 D; U% h
18. 　　　　break；
    ! N6 M/ J8 z- |8 y) x9 b
19. }

复制代码

0 b& B, R( ~. z. A推荐的代码：
* ~$ Z6 N1 T* o5 u& j: B8 j8 }

1. 
   3 N) z# I, _: m3 ]* v0 n! ^7 Y
2. int days_in_month， short_months， normal_months， long_months；
   % c* t5 [1 I6 Q( `3 C8 \7 P
3. 。。。。。。
   : N5 T2 b) ?6 N1 ^
4. switch (days_in_month)
   # W( {3 c* k# I+ M0 ~- \
5. {
   6 _9 P- O/ q/ Z" K
6. 　　case 31:
   
7. 　　　　long_months ++；
   
8. 　　　　break；
   
9. 　　case 30:
   2 B8 k4 m) ?+ h- ]8 ^5 I  q( w9 I
10. 　　　　normal_months ++；
    6 r; l3 I% b: m% h9 P( ?) t( i
11. 　　　　break；
    6 o7 k4 U0 z0 J- J* w3 v+ w' l
12. 　　case 28:
    " I3 W' y/ y" O# K( r) t
13. 　　case 29:
    4 }7 P9 O+ m1 f
14. 　　　　short_months ++；
    
15. 　　　　break；
    
16. 　　default:
    2 f1 V* P/ k, O2 h# M
17. 　　　　cout << "month has fewer than 28 or more than 31 days" << endl；
    
18. 　　　　break；
    
19. }

复制代码

（8）、将大的switch语句转为嵌套switch语句
当switch语句中的case标号很多时，为了减少比较的次数，明智的做法是把大switch语句转为嵌套switch语句。把发生频率高的case 标号放在一个switch语句中，并且是嵌套switch语句的最外层，发生相对频率相对低的case标号放在另一个switch语句中。比如，下面的程序段把相对发生频率低的情况放在缺省的case标号内。

1. 
   1 G7 @6 i- O& e
2. pMsg=ReceiveMessage();
   
3.         switch (pMsg->type)
   
4.         {
   
5.         case FREQUENT_MSG1:
   
6.         handleFrequentMsg();
   
7.         break;
   1 D6 \' P9 E3 C
8.         case FREQUENT_MSG2:
   
9.         handleFrequentMsg2();
   
10.         break;
    
11.         。。。。。。
    & u% V$ W5 R8 `5 z% l* P
12.         case FREQUENT_MSGn:
    : u- v9 T5 u$ g) g
13.         handleFrequentMsgn();
    
14.         break;
    8 v) `% g8 {/ H2 n$ l( Z
15.         default:                     //嵌套部分用来处理不经常发生的消息
    
16.         switch (pMsg->type)
    ; ~' q0 |# ^+ H! m2 ?
17.         {
    
18.         case INFREQUENT_MSG1:
    
19.         handleInfrequentMsg1();
    
20.         break;
    
21.         case INFREQUENT_MSG2:
    
22.         handleInfrequentMsg2();
    ) ^5 t7 {0 c+ f1 ~: z; D
23.         break;
    8 E1 C! S& C- _0 O: y. n
24.         。。。。。。
    " o4 E' }( m; y- ~: b
25.         case INFREQUENT_MSGm:
    
26.         handleInfrequentMsgm();
    
27.         break;
    
28.         }
    
29.         }

复制代码

如果switch中每一种情况下都有很多的工作要做，那么把整个switch语句用一个指向函数指针的表来替换会更加有效，比如下面的switch语句，有三种情况：
1 r, r1 M- W0 k. _

1. 
   
2.     enum MsgType{Msg1， Msg2， Msg3}
   
3.         switch (ReceiveMessage()
   
4.         {
   * o" d4 x5 ^! b
5.         case Msg1;
   ; {( E* g' Q/ L- |; ^* ]1 i+ {
6.         。。。。。。
   
7.         case Msg2;
   , C) B1 v; }$ x( Q- U
8.         。。。。。
   
9.         case Msg3;
   
10.         。。。。。
    
11.         }

复制代码

7 @+ O& K0 @- a$ ?: V& F: X! e为了提高执行速度，用下面这段代码来替换这个上面的switch语句。
+ c; W3 b7 n$ |

1. 
   0 A/ I& a2 b- o6 j: u
2.         /*准备工作*/
   3 A# T" R6 z  S& G! v3 H
3.         int handleMsg1(void);
   ! A+ d- C" Q- F2 E8 \+ k# ^) Y
4.         int handleMsg2(void);
   / d8 c- z2 x9 r/ Q2 m4 C
5.         int handleMsg3(void);
   # W  q1 Z$ |8 l
6.         /*创建一个函数指针数组*/
   
7.         int (*MsgFunction [])()={handleMsg1， handleMsg2， handleMsg3};
   
8.         /*用下面这行更有效的代码来替换switch语句*/
     n. j/ \* n7 |1 h6 {) U( Y
9.         status=MsgFunction[ReceiveMessage()]();

复制代码

; e. P/ R  Q, y+ Y. N' h

3 C% v: `$ Q( t0 z% t8 x

（9）、循环转置
9 N  I5 H  l  U9 b有些机器对JNZ(为0转移)有特别的指令处理，速度非常快，如果你的循环对方向不敏感，可以由大向小循环。
- h7 A; z6 o7 i4 z旧代码:
2 m) ?* b% Q* A5 j  C/ T

1. 
   " v3 {. `2 r$ o8 q! O& z
2.               for (i = 1; i <= MAX; i++)
   # R$ ?8 x: D6 w) y0 e3 F1 w( r6 k! {
3.                {
   ; I( t/ z! P0 A
4.                              。。。
   
5.                           }

复制代码

新代码:

1. 
   1 T9 C  u+ n" S* S
2.               i = MAX+1;
   
3.            while (--i)
   : O, Z) l+ Y( W# Y( }
4.                          {
   $ V6 q7 K3 C1 v% y0 {2 }9 J, `
5.                            。。。
   
6.                          }

复制代码

不过千万注意，如果指针操作使用了i值，这种方法可能引起指针越界的严重错误(i = MAX+1;)。当然你可以通过对i做加减运算来纠正，但是这样就起不到加速的作用，除非类似于以下情况：
旧代码:
, s. t1 o6 R* Q* ^; ^2 ~3 }( C

1. 
   5 J2 L. P# w8 ]
2.     char a[MAX+5];
   
3.     for (i = 1; i <= MAX; i++)
   8 E) z, m/ [% o& _* x  @5 |
4.     {
   * F! l- \! v, ?3 y  R& l
5.         *(a+i+4)=0;
   . I; K6 c! x" H  D
6.     }

复制代码

" ]4 X- _+ z+ @& R  }

新代码:
7 G) m$ \$ P: [+ [/ h: g$ T1 X

1. 
   1 @1 N$ H0 _1 v4 K1 H+ b. U
2.     i = MAX+1;
   ! T. K; d* T# X0 e. Q$ L
3.     while (--i)
   , f5 x/ X5 c' n( b  k$ k1 a3 v
4.     {
   ( [  A1 s7 R5 k: v" @) H/ D5 R* @7 N
5.         *(a+i+4)=0;
     w$ x# d# G  V
6. }

复制代码

（10）、公用代码块
( B) G* F0 v2 }8 n9 {9 a. E一些公用处理模块，为了满足各种不同的调用需要，往往在内部采用了大量的if-then-else结构，这样很不好，判断语句如果太复杂，会消耗大量的时间的，应该尽量减少公用代码块的使用。(任何情况下，空间优化和时间优化都是对立的--东楼)。当然，如果仅仅是一个(3==x)之类的简单判断，适当使用一下，也还是允许的。记住，优化永远是追求一种平衡，而不是走极端。
（11）提升循环的性能
! k3 ^& U1 P$ P7 f7 }3 _9 e要提升循环的性能，减少多余的常量计算非常有用（比如，不随循环变化的计算）。
不好的代码(在for()中包含不变的if())：
7 M4 o4 H* ]/ o/ t) t

1. 
   . }9 s+ v5 z% `; g+ O3 }/ ^
2. for( i 。。。)
   : C* Y& x5 o* n/ Q& Z% f) A
3. {
   
4. 　　if( CONSTANT0 )
   # P5 L: q- e$ A9 P
5. 　　{
   
6. 　　　　DoWork0( i )；// 假设这里不改变CONSTANT0的值
   ( ~5 J% N+ Q) L8 ]/ E
7. 　　}
   
8. 　　else
   
9. 　　{
   
10. 　　　　DoWork1( i )；// 假设这里不改变CONSTANT0的值
    5 F$ D9 s4 v, I  ^! K" }+ O
11. 　　}
    7 L' J: [: F4 p' Q; r
12. }

复制代码

推荐的代码：

1. 
   4 E3 N) e+ n/ z+ f/ q; W: N
2. if( CONSTANT0 )
   
3. {
   
4. 　　for( i 。。。)
     }8 z' n, |' u* A3 j
5. 　　{
   
6. 　　　　DoWork0( i )；
   6 P# `2 E" _9 L/ B; N# ~
7. 　　}
   
8. }
   
9. else
   
10. {
    7 J% d, L4 K0 z& P& y  n, P
11. 　　for( i 。。。)
    
12. 　　{
    
13. 　　　　DoWork1( i )；
    % c2 {" |  R0 o$ G9 F9 j4 S- `  T
14. 　　}
    
15. }

复制代码

( T( O* d! k( u* o! j

! ]: K4 U5 E7 \; {0 I4 K

如果已经知道if()的值，这样可以避免重复计算。虽然不好的代码中的分支可以简单地预测，但是由于推荐的代码在进入循环前分支已经确定，就可以减少对分支预测的依赖。
( d* F' K9 L* x4 o7 V$ B（12）、选择好的无限循环
在编程中，我们常常需要用到无限循环，常用的两种方法是while (1) 和 for (；；)。这两种方法效果完全一样，但那一种更好呢？然我们看看它们编译后的代码：
编译前：
7 e, u0 U" n- d2 _* Twhile (1)；
5 p+ f. V, i8 x5 y3 T编译后：

1 U, `) k, f- t' K: S$ a% Y4 Jmov eax，1test eax，eaxje foo+23hjmp foo+18h
# D0 ]2 m" H) T0 V3 b0 D编译前：
for (；；)；
# a& T6 t$ R+ e; k0 v编译后：
jmp foo+23h
1 y  x2 k; q9 ~0 C显然，for (；；)指令少，不占用寄存器，而且没有判断、跳转，比while (1)好。
- p0 H5 H! N( H7 l& `+ Q- h8、提高CPU的并行性
（1）使用并行代码
. b. C% S0 w9 w& x尽可能把长的有依赖的代码链分解成几个可以在流水线执行单元中并行执行的没有依赖的代码链。很多高级语言，包括C++，并不对产生的浮点表达式重新排序，因为那是一个相当复杂的过程。需要注意的是，重排序的代码和原来的代码在代码上一致并不等价于计算结果一致，因为浮点操作缺乏精确度。在一些情况下，这些优化可能导致意料之外的结果。幸运的是，在大部分情况下，最后结果可能只有最不重要的位（即最低位）是错误的。
不好的代码：

1. 
   9 l8 x0 U; V1 f
2. double a[100]， sum；
   7 S- o* ^) w/ `1 H' _( e4 G  b. A
3. int i；
   . N8 c" _6 F% u/ _$ |7 X) c
4. sum = 0.0f；
   
5. for (i=0；i<100；i++)
   
6. sum += a[i]；

复制代码

推荐的代码：

1. 
   ( |, f0 J$ e$ x' H7 x, d+ \; h
2. double a[100]， sum1， sum2， sum3， sum4， sum；
   5 t, ~, d: A) A6 a
3. int i；
   . {+ n: R/ i4 U1 f
4. sum1 = sum2 = sum3 = sum4 = 0.0；
   
5. for (i = 0；i < 100；i += 4)
   
6. {
   
7. 　　sum1 += a[i]；
   3 K4 L2 z3 H. z  q! o5 H+ P) B' k
8. 　　sum2 += a[i+1]；
   9 b+ p# L7 [1 R! _) G) `% J
9. 　　sum3 += a[i+2]；
   3 U' \' p  M4 d# X" j3 f
10. 　　sum4 += a[i+3]；
    - C* {1 h$ G, V  B. C. R7 i4 A' _
11. }
    " d7 J- f8 t3 A. J; Y
12. sum = (sum4+sum3)+(sum1+sum2)；

复制代码

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

（2）避免没有必要的读写依赖
当数据保存到内存时存在读写依赖，即数据必须在正确写入后才能再次读取。虽然AMD Athlon等CPU有加速读写依赖延迟的硬件，允许在要保存的数据被写入内存前读取出来，但是，如果避免了读写依赖并把数据保存在内部寄存器中，速度会更快。在一段很长的又互相依赖的代码链中，避免读写依赖显得尤其重要。如果读写依赖发生在操作数组时，许多编译器不能自动优化代码以避免读写依赖。所以推荐程序员手动去消除读写依赖，举例来说，引进一个可以保存在寄存器中的临时变量。这样可以有很大的性能提升。下面一段代码是一个例子：
1 \) e/ c0 i; K7 z不好的代码：

1. 
   5 Q" i, k$ F- e: E4 h
2. float x[VECLEN]， y[VECLEN]， z[VECLEN]；
   7 Z) G! m. B5 |/ ^) _$ }2 C
3. 。。。。。。
   : U/ i/ T. r* M' C# M
4. for (unsigned int k = 1；k < VECLEN；k ++)
   
5. {
   ! \5 S0 a3 T' R/ c) B/ ?
6. 　　x[k] = x[k-1] + y[k]；
   * d# v0 U) ?3 f3 c" n
7. }
   
8. for (k = 1；k <VECLEN；k++)
   
9. {
   
10. 　　x[k] = z[k] * (y[k] - x[k-1])；
    3 O5 B! L% P4 L
11. }

复制代码

推荐的代码：
9 U2 J+ }6 `  Q% z( V

1. 
   : ?! N9 k6 Z) q3 F2 C0 L1 m' Y' `
2. float x[VECLEN]， y[VECLEN]， z[VECLEN]；
   
3. 。。。。。。
   
4. float t(x[0])；
   
5. for (unsigned int k = 1；k < VECLEN；k ++)
   ( K& |6 q/ B' T5 c% D; `: e3 S
6. {
   9 T' K3 f$ `! Q
7. 　　t = t + y[k]；
   . o* v$ |9 W" P1 l0 M
8. 　　x[k] = t；
   " Z( h3 o% p4 E: m
9. }
   ! i( J! \+ ~' a0 a: t
10. t = x[0]；
    " R& C. t* ~+ a  E0 @1 ~1 O) x# p) N
11. for (k = 1；k <；VECLEN；k ++)
    
12. {
    
13. 　　t = z[k] * (y[k] - t)；
    
14. 　　x[k] = t；
    
15. }

复制代码

& m& C) a7 u( L9 m# i# T

10、循环不变计算
: d1 W2 X1 e) ]$ e对于一些不需要循环变量参加运算的计算任务可以把它们放到循环外面，现在许多编译器还是能自己干这件事，不过对于中间使用了变量的算式它们就不敢动了，所以很多情况下你还得自己干。对于那些在循环中调用的函数，凡是没必要执行多次的操作通通提出来，放到一个init函数里，循环前调用。另外尽量减少喂食次数，没必要的话尽量不给它传参，需要循环变量的话让它自己建立一个静态循环变量自己累加，速度会快一点。
3 a: m# j; V1 n3 e还有就是结构体访问，东楼的经验，凡是在循环里对一个结构体的两个以上的元素执行了访问，就有必要建立中间变量了(结构这样，那C++的对象呢?想想看)，看下面的例子:
旧代码:
$ {. |' T. r  \' {, S4 f& ^

1. 
   " o1 Z3 v0 c. e, C
2.     total =
   
3.     a->b->c[4]->aardvark +
   
4.     a->b->c[4]->baboon +
   * U8 I0 l3 R. c7 a- o
5.     a->b->c[4]->cheetah +
   - @2 L3 a9 m, E  E: A" z
6.     a->b->c[4]->dog;

复制代码

9 U8 ^! b5 I1 G* M: t5 L  L

新代码:

1. 
   ' e7 Y3 [2 ~0 c, J9 U
2.     struct animals * temp = a->b->c[4];
   
3.     total =
   $ I0 s8 V4 @1 H/ C% R* j' h
4.     temp->aardvark +
   
5.     temp->baboon +
   
6.     temp->cheetah +
   0 `3 J7 m+ d9 L- \
7.     temp->dog;

复制代码

一些老的C语言编译器不做聚合优化，而符合ANSI规范的新的编译器可以自动完成这个优化，看例子:
+ K, N& R5 J) z; j1 C

1. 
   & p4 A9 S) L- Z0 G. E! x: |+ c! z
2.     float a， b， c， d， f， g;
   
3.     。。。
   
4.     a = b / c * d;
   ! J+ B9 M9 a9 P
5.     f = b * g / c;

复制代码

这种写法当然要得，但是没有优化
6 s( p6 o- m9 r3 [0 ]; {

1. 
   
2.   float a， b， c， d， f， g;
   
3.     。。。
   
4.     a = b / c * d;
   
5.     f = b / c * g;

复制代码

如果这么写的话，一个符合ANSI规范的新的编译器可以只计算b/c一次，然后将结果代入第二个式子，节约了一次除法运算。
11、函数优化 （1）Inline函数
在C++中，关键字Inline可以被加入到任何函数的声明中。这个关键字请求编译器用函数内部的代码替换所有对于指出的函数的调用。这样做在两个方面快于函数调用：第一，省去了调用指令需要的执行时间；第二，省去了传递变元和传递过程需要的时间。但是使用这种方法在优化程序速度的同时，程序长度变大了，因此需要更多的ROM。使用这种优化在Inline函数频繁调用并且只包含几行代码的时候是最有效的。
（2）不定义不使用的返回值
函数定义并不知道函数返回值是否被使用，假如返回值从来不会被用到，应该使用void来明确声明函数不返回任何值。
6 \# Z+ r. Y7 s/ r（3）减少函数调用参数
使用全局变量比函数传递参数更加有效率。这样做去除了函数调用参数入栈和函数完成后参数出栈所需要的时间。然而决定使用全局变量会影响程序的模块化和重入，故要慎重使用。
（4）所有函数都应该有原型定义
0 s% N) t& @1 j* A2 q8 u( A* b一般来说，所有函数都应该有原型定义。原型定义可以传达给编译器更多的可能用于优化的信息。
2 F: t! i% `5 r9 k（5）尽可能使用常量(const)
尽可能使用常量(const)。C++ 标准规定，如果一个const声明的对象的地址不被获取，允许编译器不对它分配储存空间。这样可以使代码更有效率，而且可以生成更好的代码。
! ]3 O, W& \0 f3 L* y8 y（6）把本地函数声明为静态的(static)
如果一个函数只在实现它的文件中被使用，把它声明为静态的(static)以强制使用内部连接。否则，默认的情况下会把函数定义为外部连接。这样可能会影响某些编译器的优化——比如，自动内联。
5 h+ m; y8 M8 L: {& t( T12、采用递归
9 i5 L( e0 @, j6 c& x+ v) {/ X; O与LISP之类的语言不同，C语言一开始就病态地喜欢用重复代码循环，许多C程序员都是除非算法要求，坚决不用递归。事实上，C编译器们对优化递归调用一点都不反感，相反，它们还很喜欢干这件事。只有在递归函数需要传递大量参数，可能造成瓶颈的时候，才应该使用循环代码，其他时候，还是用递归好些。
13、变量
（1）register变量
7 B0 W5 O7 {; {: G7 G1 o在声明局部变量的时候可以使用register关键字。这就使得编译器把变量放入一个多用途的寄存器中，而不是在堆栈中，合理使用这种方法可以提高执行速度。函数调用越是频繁，越是可能提高代码的速度。
( R6 k0 F! A  Y' ^在最内层循环避免使用全局变量和静态变量，除非你能确定它在循环周期中不会动态变化，大多数编译器优化变量都只有一个办法，就是将他们置成寄存器变量，而对于动态变量，它们干脆放弃对整个表达式的优化。尽量避免把一个变量地址传递给另一个函数，虽然这个还很常用。C语言的编译器们总是先假定每一个函数的变量都是内部变量，这是由它的机制决定的，在这种情况下，它们的优化完成得最好。但是，一旦一个变量有可能被别的函数改变，这帮兄弟就再也不敢把变量放到寄存器里了，严重影响速度。看例子：
a = b();c(&d);
) w, Q4 C- b* t2 Y; E) I因为d的地址被c函数使用，有可能被改变，编译器不敢把它长时间的放在寄存器里，一旦运行到c(&d)，编译器就把它放回内存，如果在循环里，会造成N次频繁的在内存和寄存器之间读写d的动作，众所周知，CPU在系统总线上的读写速度慢得很。比如你的赛杨300，CPU主频300，总线速度最多66M，为了一个总线读，CPU可能要等4-5个周期，得。。得。。得。。想起来都打颤。
9 T3 O6 M, ~( j- S（2）、同时声明多个变量优于单独声明变量（3）、短变量名优于长变量名，应尽量使变量名短一点（4）、在循环开始前声明变量
14、使用嵌套的if结构
) L0 m! G/ u4 V' V" M2 X在if结构中如果要判断的并列条件较多，最好将它们拆分成多个if结构，然后嵌套在一起，这样可以避免无谓的判断。

该方案主要是考虑到在嵌入式开发中对程序执行速度的要求特别高，所以该方案主要是为了优化程序的执行速度。
( q- G3 E" {7 A. x& m; `注意：优化是有侧重点的，优化是一门平衡的艺术，它往往要以牺牲程序的可读性或者增加代码长度为代价。

5 u/ j$ ^) ^- s15、尽量不要定义成全局变量
$ ]8 T% ^% ]5 H. }先来看一下局部变量、全局变量、静态局部变量、静态全局变量的异同。
- L% k  Q9 s: X4 @▶局部变量：在一个函数中或复合语句中定义的变量，在动态存储区分配存储单元，在调用时动态分配，在函数或复合语句结束时自动释放。

▶静态局部变量：在一个函数中定义局部变量时，若加上static声明，则此变量为静态局部变量，在静态存储区分配存储单元，在程序运行期间都不释放；静态局部变量只能在该函数中使用；静态局部变量在编译时赋值（若在定义时未进行赋值处理，则默认赋值为0（对数值型变量）或空字符（对字符型变量））；静态局部变量在函数调用结束后不自动释放，保留函数调用结束后的值。
; K" V  e5 T5 l' q▶全局变量：在函数外定义的变量称为全局变量；全局变量在静态存储区分配存储单元，在程序运行期间都不释放，在文件中的函数均可调用该全局变量，其他文件内的函数调用全局变量，需加extern声明。
; Q+ f1 v( `$ D% N5 {▶静态全局变量：在函数外定义变量时，若加上staTIc声明，则此变量为静态全局变量；静态全局变量在静态存储区分配存储单元，在程序运行期间都不释放，静态全局变量在编译时赋值（若在定义时未进行赋值处理，则默认赋值为0（对数值型变量）或空字符（对字符型变量））；只能在当前文件中使用。
0 K! s* y& E6 s9 D4 b▶小结：
一般情况下就定义成局部变量，这样不仅运行更高效，而且很方便移植。局部变量大多定位于MCU内部的寄存器中，在绝大多数MCU中，使用寄存器操作速度比数据存储器快，指令也更多更灵活,有利于生成质量更高的代码，而且局部变量所占用的寄存器和数据存储器在不同的模块中可以重复利用。
6 F: }5 p: N5 N& _9 M6 _当中断里需要用到的变量时，就需要定义成全局变量，并且加volaTIle修饰一下，防止编译器优化。如果数据是只读的比如数码管的断码、汉字取模的字库需要放在ROM里，这样可以节省RAM，51单片机是加code，高级点的单片机都是加const修饰。
1 Y; k, V+ j* e  \) Z( b( c
- j. R- w& k8 u0 J2 ?' H# C; N

非常好，赞！