Go最新数十种嵌入式 C 语言代码优化的经验和方法_嵌入式代码优化方案，2024年最新【设计思想解读开源框架】

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

 = C0 + C1 * (log2 (numerator) - log2 (denominator)).

对于ARM处理器，这个版本需要20+4.3N次循环。这是一个消耗很大的操作，应该尽可能的避免执行。有时，可以通过乘法表达式来替代除法。


例如，假如我们知道b是正数并且b\*c是个整数，那么(a/b)>c可以改写为a>(c \* b)。如果确定操作数是无符号unsigned的，使用无符号unsigned除法更好一些，因为它比有符号signed除法效率高。


### 合并除法和取余数


在一些场景中，同时需要除法（x/y）和取余数（x%y）操作。这种情况下，编译器可以通过调用一次除法操作返回除法的结果和余数。如果既需要除法的结果又需要余数，我们可以将它们写在一起，如下所示：

int func_div_and_mod (int a, int b)
{
return (a / b) + (a % b);
}

### 通过2的幂次进行除法和取余数


如果除法中的除数是2的幂次，我们可以更好的优化除法。编译器使用移位操作来执行除法。因此，我们需要尽可能的设置除数为2的幂次（例如64而不是66）。并且依然记住，无符号unsigned整数除法执行效率高于有符号signed整形出发。

typedef unsigned int uint;

uint div32u (uint a)
{
return a / 32;
}
int div32s (int a)
{
return a / 32;
}

上面两种除法都避免直接调用除法函数，并且无符号unsigned的除法使用更少的计算机指令。由于需要移位到0和负数，有符号signed的除法需要更多的时间执行。


### 取模的一种替代方法


我们使用取余数操作符来提供算数取模。但有时可以结合使用if语句进行取模操作。考虑如下两个例子：

uint modulo_func1 (uint count)
{
return (++count % 60);
}

uint modulo_func2 (uint count)
{
if (++count >= 60)
count = 0;
return (count);
}

优先使用if语句，而不是取余数运算符，因为if语句的执行速度更快。这里注意新版本函数只有在我们知道输入的count结余0至59时在能正确的工作。


### 使用数组下标


如果你想给一个变量设置一个代表某种意思的字符值，你可能会这样做：

switch ( queue )
{
case 0 : letter = ‘W’;
break;
case 1 : letter = ‘S’;
break;
case 2 : letter = ‘U’;
break;
}

或者这样做：

if ( queue == 0 )
letter = ‘W’;
else if ( queue == 1 )
letter = ‘S’;
else letter = ‘U’;

一种更简洁、更快的方法是使用数组下标获取字符数组的值。如下：

static char *classes=“WSU”;
letter = classes[queue];

### 全局变量


全局变量绝不会位于寄存器中。使用指针或者函数调用，可以直接修改全局变量的值。因此，编译器不能将全局变量的值缓存在寄存器中，但这在使用全局变量时便需要额外的（常常是不必要的）读取和存储。所以，在重要的循环中我们不建议使用全局变量。


如果函数过多的使用全局变量，比较好的做法是拷贝全局变量的值到局部变量，这样它才可以存放在寄存器。这种方法仅仅适用于全局变量不会被我们调用的任意函数使用。例子如下：

int f(void);
int g(void);
int errs;
void test1(void)
{
errs += f();
errs += g();
}
void test2(void)
{
int localerrs = errs;
localerrs += f();
localerrs += g();
errs = localerrs;
}

注意，test1必须在每次增加操作时加载并存储全局变量errs的值，而test2存储localerrs于寄存器并且只需要一个计算机指令。


### 使用别名


考虑如下的例子：

void func1( int *data )
{
int i;
for(i=0; i<10; i++)
{
anyfunc( *data, i);
}
}

尽管\*data的值可能从未被改变，但编译器并不知道anyfunc函数不会修改它，所以程序必须在每次使用它的时候从内存中读取它。如果我们知道变量的值不会被改变，那么就应该使用如下的编码：

void func1( int *data )
{
int i;
int localdata;
localdata = *data;
for(i=0; i<10; i++)
{
anyfunc (localdata, i);
}
}

这为编译器优化代码提供了条件。


### 变量的生命周期分割


由于处理器中寄存器是固定长度的，程序中数字型变量在寄存器中的存储是有一定限制的。


有些编译器支持“生命周期分割”（live-range splitting），也就是说在程序的不同部分，变量可以被分配到不同的寄存器或者内存中。


变量的生命周期开始于对它进行的最后一次赋值，结束于下次赋值前的最后一次使用。在生命周期内，变量的值是有效的，也就是说变量是活着的。不同生命周期之间，变量的值是不被需要的，也就是说变量是死掉的。


这样，寄存器就可以被其余变量使用，从而允许编译器分配更多的变量使用寄存器。


需要使用寄存器分配的变量数目需要超过函数中不同变量生命周期的个数。如果不同变量生命周期的个数超过了寄存器的数目，那么一些变量必须临时存储于内存。这个过程就称之为分割。


编译器首先分割最近使用的变量，用以降低分割带来的消耗。禁止变量生命周期分割的方法如下：


* 限定变量的使用数量：这个可以通过保持函数中的表达式简单、小巧、不使用太多的变量实现。将较大的函数拆分为小而简单的函数也会达到很好的效果。
* 对经常使用到的变量采用寄存器存储：这样允许我们告诉编译器该变量是需要经常使用的，所以需要优先存储于寄存器中。然而，在某种情况下，这样的变量依然可能会被分割出寄存器。


### 变量类型


C编译器支持基本类型：char、short、int、long(包括有符号signed和无符号unsigned）、float和double。使用正确的变量类型至关重要，因为这可以减少代码和数据的大小并大幅增加程序的性能。


### 局部变量


我们应该尽可能的不使用char和short类型的局部变量。对于char和short类型，编译器需要在每次赋值的时候将局部变量减少到8或者16位。这对于有符号变量称之为有符号扩展，对于无符号变量称之为零扩展。


这些扩展可以通过寄存器左移24或者16位，然后根据有无符号标志右移相同的位数实现，这会消耗两次计算机指令操作（无符号char类型的零扩展仅需要消耗一次计算机指令）。


可以通过使用int和unsigned int类型的局部变量来避免这样的移位操作。这对于先加载数据到局部变量，然后处理局部变量数据值这样的操作非常重要。无论输入输出数据是8位或者16位，将它们考虑为32位是值得的。


考虑下面的三个函数：

int wordinc (int a)
{
return a + 1;
}
short shortinc (short a)
{
return a + 1;
}
char charinc (char a)
{
return a + 1;
}

尽管结果均相同，但是第一个程序片段运行速度高于后两者。


### 指针


我们应该尽可能的使用引用值的方式传递结构数据，也就是说使用指针，否则传递的数据会被拷贝到栈中，从而降低程序的性能。我曾见过一个程序采用传值的方式传递非常大的结构数据，然后这可以通过一个简单的指针更好的完成。


函数通过参数接受结构数据的指针，如果我们确定不改变数据的值，我们需要将指针指向的内容定义为常量。例如：

void print_data_of_a_structure (const Thestruct *data_pointer)
{
…printf contents of the structure…
}

这个示例告诉编译器函数不会改变外部参数的值（使用const修饰），并且不用在每次访问时都进行读取。同时，确保编译器限制任何对只读结构的修改操作从而给予结构数据额外的保护。


### 指针链


指针链经常被用于访问结构数据。例如，常用的代码如下：

typedef struct { int x, y, z; } Point3;
typedef struct { Point3 *pos, *direction; } Object;

void InitPos1(Object *p)
{
p->pos->x = 0;
p->pos->y = 0;
p->pos->z = 0;
}

然而，这种的代码在每次操作时必须重复调用p->pos，因为编译器不知道p->pos->x与p->pos是相同的。一种更好的方法是缓存p->pos到一个局部变量：

void InitPos2(Object *p)
{
Point3 *pos = p->pos;
pos->x = 0;
pos->y = 0;
pos->z = 0;
}

另一种方法是在Object结构中直接包含Point3类型的数据，这能完全消除对Point3使用指针操作。


### 条件执行


条件执行语句大多在if语句中使用，也在使用关系运算符（<，==，>等）或者布尔值表达式（&&，！等）计算复杂表达式时使用。对于包含函数调用的代码片段，由于函数返回值会被销毁，因此条件执行是无效的。


因此，保持if和else语句尽可能简单是十分有益处的，因为这样编译器可以集中处理它们。关系表达式应该写在一起。


下面的例子展示编译器如何使用条件执行：

int g(int a, int b, int c, int d)
{
if (a > 0 && b > 0 && c < 0 && d < 0)
// grouped conditions tied up together//
return a + b + c + d;
return -1;
}

由于条件被聚集到一起，编译器能够将他们集中处理。


### 布尔表达式和范围检查


一个常用的布尔表达式是用于判断变量是否位于某个范围内，例如，检查一个图形坐标是否位于一个窗口内：

bool PointInRectangelArea (Point p, Rectangle *r)
{
return (p.x >= r->xmin && p.x < r->xmax &&
p.y >= r->ymin && p.y < r->ymax);
}

这里有一种更快的方法：x>min && x<max可以转换为(unsigned)(x-min)<(max-min)。这对于min等于0时更为有益。优化后的代码如下：

bool PointInRectangelArea (Point p, Rectangle *r)
{
return ((unsigned) (p.x - r->xmin) < r->xmax &&
(unsigned) (p.y - r->ymin) < r->ymax);

}

### 布尔表达式和零值比较


处理器的标志位在比较指令操作后被设置。标志位同样可以被诸如MOV、ADD、AND、MUL等基本算术和裸机指令改写。如果数据指令设置了标志位，N和Z标志位也将与结果与0比较一样进行设置。N标志表示结果是否是负值，Z标志表示结果是否是0。


C语言中，处理器中的N和Z标志位与下面的指令联系在一起：有符号关系运算x<0，x>=0，x0，x!=0；无符号关系运算x0，x!=0（或者x>0）。


C代码中每次关系运算符的调用，编译器都会发出一个比较指令。如果操作符是上面提到的，编译器便会优化掉比较指令。例如：

int aFunction(int x, int y)
{
if (x + y < 0)
return 1;
else
return 0;
}

尽可能的使用上面的判断方式，这可以在关键循环中减少比较指令的调用，进而减少代码体积并提高代码性能。C语言没有借位和溢出位的概念，因此，如果不借助汇编，不可能直接使用借位标志C和溢出位标志V。但编译器支持借位（无符号溢出），例如：

int sum(int x, int y)
{
int res;
res = x + y;
if ((unsigned) res < (unsigned) x) // carry set? //
res++;
return res;
}

### 懒检测开发


在if(a>10 && b=4)这样的语句中，确保AND表达式的第一部分最可能较快的给出结果（或者最早、最快计算），这样第二部分便有可能不需要执行。


### 用switch()函数替代if…else…


对于涉及if…else…else…这样的多条件判断，例如：

if( val == 1)
dostuff1();
else if (val == 2)
dostuff2();
else if (val == 3)
dostuff3();

使用switch可能更快：

switch( val )
{
case 1: dostuff1(); break;

case 2: dostuff2(); break;

case 3: dostuff3(); break;

}

在if()语句中，如果最后一条语句命中，之前的条件都需要被测试执行一次。Switch允许我们不做额外的测试。如果必须使用if…else…语句，将最可能执行的放在最前面。


### 二分中断


使用二分方式中断代码而不是让代码堆成一列，不要像下面这样做：

if(a1) {
} else if(a2) {
} else if(a3) {
} else if(a4) {
} else if(a5) {
} else if(a6) {
} else if(a7) {
} else if(a8)

{
}

使用下面的二分方式替代它，如下：

if(a<=4) {
if(a1) {
} else if(a2) {
} else if(a3) {
} else if(a4) {

}

}
else
{
if(a5) {
} else if(a6) {
} else if(a7) {
} else if(a8) {
}
}

或者如下：

if(a<=4)
{
if(a<=2)
{
if(a1)
{
/* a is 1 /
}
else
{
/ a must be 2 */
}
}
else
{
if(a3)
{
/* a is 3 /
}
else
{
/ a must be 4 /
}
}
}
else
{
if(a<=6)
{
if(a==5)
{
/ a is 5 /
}
else
{
/ a must be 6 /
}
}
else
{
if(a==7)
{
/ a is 7 /
}
else
{
/ a must be 8 */
}
}
}

比较如下两种case语句：


======001


### switch语句vs查找表


Switch的应用场景如下：


* 调用一到多个函数
* 设置变量值或者返回一个值
* 执行一到多个代码片段


如果case标签很多，在switch的前两个使用场景中，使用查找表可以更高效的完成。例如下面的两种转换字符串的方式：

char * Condition_String1(int condition) {
switch(condition) {
case 0: return “EQ”;
case 1: return “NE”;
case 2: return “CS”;
case 3: return “CC”;
case 4: return “MI”;
case 5: return “PL”;
case 6: return “VS”;
case 7: return “VC”;
case 8: return “HI”;
case 9: return “LS”;
case 10: return “GE”;
case 11: return “LT”;
case 12: return “GT”;
case 13: return “LE”;
case 14: return “”;
default: return 0;
}
}

char * Condition_String2(int condition) {
if ((unsigned) condition >= 15) return 0;
return
“EQ\0NE\0CS\0CC\0MI\0PL\0VS\0VC\0HI\0LS\0GE\0LT\0GT\0LE\0\0” +
3 * condition;
}

第一个程序需要240 bytes，而第二个仅仅需要72 bytes。


### 循环


循环是大多数程序中的常用的结构；程序执行的大部分时间发生在循环中，因此十分值得在循环执行时间上下一番功夫。


#### 循环终止


如果不加注意，循环终止条件的编写会导致额外的负担。我们应该使用计数到零的循环和简单的循环终止条件。简单的终止条件消耗更少的时间。看下面计算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);
}

第二个程序的fact2\_func执行效率高于第一个。


#### 更快的for()循环


这是一个简单而高效的概念。通常，我们编写for循环代码如下：

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

i从0循环到9。如果我们不介意循环计数的顺序，我们可以这样写：

for( i=10; i–; ) { … }

这样快的原因是因为它能更快的处理i的值–测试条件是：i是非零的吗？如果这样，递减i的值。对于上面的代码，处理器需要计算“计算i减去10，其值非负吗？如果非负，i递增并继续”。


简单的循环却有很大的不同。这样，i从9递减到0，这样的循环执行速度更快。


这里的语法有点奇怪，但确实合法的。循环中的第三条语句是可选的（无限循环可以写为for(;😉）。如下代码拥有同样的效果：



![img](https://img-blog.csdnimg.cn/img_convert/7fafd7d10db679950879c2b135530d4d.png)
![img](https://img-blog.csdnimg.cn/img_convert/2414b36682f05407ce72577eee2fd0ca.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**




这是一个简单而高效的概念。通常，我们编写for循环代码如下：

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

i从0循环到9。如果我们不介意循环计数的顺序，我们可以这样写：

for( i=10; i–; ) { … }

这样快的原因是因为它能更快的处理i的值–测试条件是：i是非零的吗？如果这样，递减i的值。对于上面的代码，处理器需要计算“计算i减去10，其值非负吗？如果非负，i递增并继续”。


简单的循环却有很大的不同。这样，i从9递减到0，这样的循环执行速度更快。


这里的语法有点奇怪，但确实合法的。循环中的第三条语句是可选的（无限循环可以写为for(;😉）。如下代码拥有同样的效果：



[外链图片转存中...(img-pKfqKiPc-1715523051601)]
[外链图片转存中...(img-hLy9PEqw-1715523051601)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**