如何做网站的搜索栏,电脑培训班在哪里有最近的,天津外贸公司网站制作,大连工程局点击蓝字关注我们在本篇文章中#xff0c;我(指原作者)收集了很多经验和方法。应用这些经验和方法#xff0c;可以帮助我们从执行速度和内存使用等方面来优化C语言代码。简介在最近的一个项目中#xff0c;我们需要开发一个运行在移动设备上但不保证图像高质量的轻量级JPEG库… 点击蓝字关注我们在本篇文章中我(指原作者)收集了很多经验和方法。应用这些经验和方法可以帮助我们从执行速度和内存使用等方面来优化C语言代码。简介在最近的一个项目中我们需要开发一个运行在移动设备上但不保证图像高质量的轻量级JPEG库。期间我总结了一些让程序运行更快的方法。在本篇文章中我收集了一些经验和方法。应用这些经验和方法可以帮助我们从执行速度和内存使用等方面来优化C语言代码。尽管在C代码优化方面有很多的指南但是关于编译和你使用的编程机器方面的优化知识却很少。通常为了让你的程序运行的更快程序的代码量可能需要增加。代码量的增加又可能会对程序的复杂度和可读性带来不利的影响。这对于在手机、PDA等对于内存使用有很多限制的小型设备上编写程序时是不被允许的。因此在代码优化时我们的座右铭应该是确保内存使用和执行速度两方面都得到优化。声明实际上在我的项目中我使用了很多优化ARM编程的方法该项目是基于ARM平台的也使用了很多互联网上面的方法。但并不是所有文章提到的方法都能起到很好的作用。所以我对有用的和高效的方法进行了总结收集。同时我还修改了其中的一些方法使他们适用于所有的编程环境而不是局限于ARM环境。哪里需要使用这些方法没有这一点所有的讨论都无从谈起。程序优化最重要的就是找出待优化的地方也就是找出程序的哪些部分或者哪些模块运行缓慢亦或消耗大量的内存。只有程序的各部分经过了优化程序才能执行的更快。程序中运行最多的部分特别是那些被程序内部循环重复调用的方法最该被优化。对于一个有经验的码农发现程序中最需要被优化的部分往往很简单。此外还有很多工具可以帮助我们找出需要优化的部分。我使用过Visual C内置的性能工具profiler来找出程序中消耗最多内存的地方。另一个我使用过的工具是英特尔的Vtune它也能很好的检测出程序中运行最慢的部分。根据我的经验内部或嵌套循环调用第三方库的方法通常是导致程序运行缓慢的最主要的起因。整形数如果我们确定整数非负就应该使用unsigned int而不是int。有些处理器处理无符号unsigned 整形数的效率远远高于有符号signed整形数这是一种很好的做法也有利于代码具体类型的自解释。因此在一个紧密循环中声明一个int整形变量的最好方法是register unsigned int variable_name;记住整形in的运算速度高浮点型float并且可以被处理器直接完成运算而不需要借助于FPU浮点运算单元或者浮点型运算库。尽管这不保证编译器一定会使用到寄存器存储变量也不能保证处理器处理能更高效处理unsigned整型但这对于所有的编译器是通用的。例如在一个计算包中如果需要结果精确到小数点后两位我们可以将其乘以100然后尽可能晚的把它转换为浮点型数字。除法和取余数在标准处理器中对于分子和分母一个32位的除法需要使用20至140次循环操作。除法函数消耗的时间包括一个常量时间加上每一位除法消耗的时间。Time (numerator / denominator) C0 C1* log2 (numerator / denominator) C0 C1 * (log2 (numerator) - log2 (denominator)).对于ARM处理器这个版本需要204.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 *classesWSU;
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(i0; i10; i) { anyfunc( *data, i); }
}尽管*data的值可能从未被改变但编译器并不知道anyfunc函数不会修改它所以程序必须在每次使用它的时候从内存中读取它。如果我们知道变量的值不会被改变那么就应该使用如下的编码void func1( int *data )
{ int i; int localdata; localdata *data; for(i0; i10; 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);
}这里有一种更快的方法xmin xmax可以转换为(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标志位与下面的指令联系在一起有符号关系运算x0x0x0x!0无符号关系运算x0x!0或者x0。C代码中每次关系运算符的调用编译器都会发出一个比较指令。如果操作符是上面提到的编译器便会优化掉比较指令。例如int aFunction(int x, int y)
{if (x y 0)return 1;elsereturn 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(a10 b4)这样的语句中确保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(a4) {if(a1) {} else if(a2) {} else if(a3) {} else if(a4) {}
}
else
{if(a5) {} else if(a6) {} else if(a7) {} else if(a8) {}
}或者如下if(a4)
{if(a2){if(a1){/* a is 1 */}else{/* a must be 2 */}}else{if(a3){/* a is 3 */}else{/* a must be 4 */}}
}
else
{if(a6){if(a5){/* a is 5 */}else{/* a must be 6 */}}else{if(a7){/* a is 7 */}else{/* a must be 8 */}}
}比较如下两种case语句001switch语句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;returnEQ\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( i0; i10; i){ ... }i从0循环到9。如果我们不介意循环计数的顺序我们可以这样写for( i10; i--; ) { ... }这样快的原因是因为它能更快的处理i的值–测试条件是i是非零的吗如果这样递减i的值。对于上面的代码处理器需要计算“计算i减去10其值非负吗如果非负i递增并继续”。简单的循环却有很大的不同。这样i从9递减到0这样的循环执行速度更快。这里的语法有点奇怪但确实合法的。循环中的第三条语句是可选的无限循环可以写为for(;;)。如下代码拥有同样的效果for(i10; i; i--){}或者更进一步的for(i10; i!0; i--){}这里我们需要记住的是循环必须终止于0因此如果在50到80之间循环这不会起作用并且循环计数器是递减的。使用递增循环计数器的代码不享有这种优化。合并循环如果一个循环能解决问题坚决不用二个。但如果你需要在循环中做很多工作这坑你并不适合处理器的指令缓存。这种情况下两个分开的循环可能会比单个循环执行的更快。下面是一个例子002函数循环调用函数时总是会有一定的性能消耗。不仅程序指针需要改变而且使用的变量需要压栈并分配新变量。为提升程序的性能在函数这点上有很多可以优化的。在保持程序代码可读性的同时也需要代码的大小是可控的。如果在循环中一个函数经常被调用那么就将循环纳入到函数中这样可以减少重复的函数调用。代码如下for(i0 ; i100 ; i)
{func(t,i);
}
-
-
-
void func(int w,d)
{lots of stuff.
}应改为func(t);
-
-
-
void func(w)
{for(i0 ; i100 ; i){//lots of stuff.}
}循环展开简单的循环可以展开以获取更好的性能但需要付出代码体积增加的代价。循环展开后循环计数应该越来越小从而执行更少的代码分支。如果循环迭代次数只有几次那么可以完全展开循环以便消除循坏带来的负担。这会带来很大的不同。循环展开可以带非常可观的节省性能原因是代码不用每次循环需要检查和增加i的值。例如003编译器通常会像上面那样展开简单的迭代次数固定的循环。但是像下面的代码for(i0;i limit;i) { ... }下面的代码Example 1明显比使用循环的方式写的更长但却更有效率。block-sie的值设置为8仅仅适用于测试的目的只要我们重复执行“loop-contents”相同的次数都会有很好的效果。在这个例子中循环条件每8次迭代才会被检查而不是每次都进行检查。由于不知道迭代的次数一般不会被展开。因此尽可能的展开循环可以让我们获得更好的执行速度。//Example 1#includeSTDIO.H#define BLOCKSIZE (8)void 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, i1);printf(process(%d)\n, i2);printf(process(%d)\n, i3);printf(process(%d)\n, i4);printf(process(%d)\n, i5);printf(process(%d)\n, i6);printf(process(%d)\n, i7);/* 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);}
}}统计非零位的数量通过不断的左移提取并统计最低位示例程序1高效的检查一个数组中有几个非零位。示例程序2被循环展开四次然后通过将四次移位合并成一次来优化代码。经常展开循环可以提供很多优化的机会。//Example - 1int countbit1(uint n)
{int bits 0;while (n ! 0){if (n 1) bits;n 1;}return bits;
}//Example - 2int countbit2(uint n)
{int bits 0;while (n ! 0){if (n 1) bits;if (n 2) bits;if (n 4) bits;if (n 8) bits;n 4;}return bits;
}尽早的断开循环通常循环并不需要全部都执行。例如如果我们在从数组中查找一个特殊的值一经找到我们应该尽可能早的断开循环。例如如下循环从10000个整数中查找是否存在-99。found FALSE;
for(i0;i10000;i)
{if( list[i] -99 ){found TRUE;}
}if( found ) printf(Yes, there is a -99. Hooray!\n);上面的代码可以正常工作但是需要循环全部执行完毕而不论是否我们已经查找到。更好的方法是一旦找到我们查找的数字就终止继续查询。found FALSE;
for(i0; i10000; i)
{if( list[i] -99 ){found TRUE;break;}
}
if( found ) printf(Yes, there is a -99. Hooray!\n);假如待查数据位于第23个位置上程序便会执行23次从而节省9977次循环。函数设计设计小而简单的函数是个很好的习惯。这允许寄存器可以执行一些诸如寄存器变量申请的优化是非常高效的。函数调用的性能消耗函数调用对于处理器的性能消耗是很小的只占有函数执行工作中性能消耗的一小部分。参数传入函数变量寄存器中有一定的限制。这些参数必须是整型兼容的charshortsints和floats都占用一个字或者小于四个字大小包括占用2个字的doubles和long longs。如果参数限制个数为4那么第五个和之后的字就会存储在栈上。这便在调用函数是需要从栈上加载参数从而增加存储和读取的消耗。看下面的代码int f1(int a, int b, int c, int d) {return a b c d;
}int g1(void) {return f1(1, 2, 3, 4);
}int f2(int a, int b, int c, int d, int e, int f) {return a b c d e f;
}ing g2(void) {return f2(1, 2, 3, 4, 5, 6);
}函数g2中的第五个和第六个参数存储于栈上并在函数f2中进行加载会多消耗2个参数的存储。减少函数参数传递消耗减少函数参数传递消耗的方法有尽量保证函数使用少于四个参数。这样就不会使用栈来存储参数值。如果函数需要多于四个的参数尽量确保使用后面参数的价值高于让其存储于栈所付出的代价。通过指针传递参数的引用而不是传递参数结构体本身。将参数放入一个结构体并通过指针传入函数这样可以减少参数的数量并提高可读性。尽量少用占用两个字大小的long类型参数。对于需要浮点类型的程序double也因为占用两个字大小而应尽量少用。避免函数参数既存在于寄存器又存在于栈中称之为参数拆分。现在的编译器对这种情况处理的不够高效所有的寄存器变量也会放入到栈中。避免变参。变参函数将参数全部放入栈。叶子函数不调用任何函数的函数称之为叶子函数。在以下应用中近一半的函数调用是调用叶子函数。由于不需要执行寄存器变量的存储和读取叶子函数在任何平台都很高效。寄存器变量读取的性能消耗相比于使用四五个寄存器变量的叶子函数所做的工作带来的系能消耗是非常小的。所以尽可能的将经常调用的函数写成叶子函数。函数调用的次数可以通过一些工具检查。下面是一些将一个函数编译为叶子函数的方法避免调用其他函数包括那些转而调用C库的函数比如除法或者浮点数操作函数。对于简短的函数使用__inline修饰。内联函数内联函数禁用所有的编译选项。使用__inline修饰函数导致函数在调用处直接替换为函数体。这样代码调用函数更快但增加代码的大小特别在函数本身比较大而且经常调用的情况下。__inline int square(int x) {return x * x;
}#include MATH.Hdouble length(int x, int y){return sqrt(square(x) square(y));
}使用内联函数的好处如下没有函数调用负担。函数调用处直接替换为函数体因此没有诸如读取寄存器变量等性能消耗。更小的参数传递消耗。由于不需要拷贝变量传递参数的消耗更小。如果参数是常量编译器可以提供更好的优化。内联函数的缺陷是如果调用的地方很多代码的体积会变得很大。这主要取决于函数本身的大小和调用的次数。仅对重要的函数使用inline是明智的。如果使用得当内联函数甚至可以减少代码的体积函数调用会产生一些计算机指令但是使用内联的优化版本可能产生更少的计算机指令。使用查找表函数通常可以设计成查找表这样可以显著提升性能。查找表的精确度比通常的计算低但对于一般的程序并没什么差异。许多信号处理程序例如调制解调器解调软件使用很多非常消耗计算性能的sin和cos函数。对于实时系统精确性不是特别重要sin、cos查找表可能更合适。当使用查找表时尽可能将相似的操作放入查找表这样比使用多个查找表更快更能节省存储空间。浮点运算尽管浮点运算对于所有的处理器都很耗时但对于实现信号处理软件时我们仍然需要使用。在编写浮点操作程序时记住如下几点浮点除法很慢。浮点除法比加法或者乘法慢两倍。通过使用常量将除法转换为乘法例如xx/3.0可以替换为xx*(1.0/3.0)。常量的除法在编译期间计算。使用float代替double。Float类型的变量消耗更好的内存和寄存器并由于精度低而更加高效。如果精度够用尽可能使用float。避免使用先验函数。先验函数例如sin、exp和log是通过一系列的乘法和加法实现的使用了精度扩展。这些操作比通常的乘法至少慢十倍。简化浮点运算表达式。编译器并不能将应用于整型操作的优化手段应用于浮点操作。例如3*(x/3)可以优化为x而浮点运算就会损失精度。因此如果知道结果正确进行必要手工浮点优化是有必要的。然而浮点运算的表现可能不能满足特定软件对性能的需求。这种情况下最好的办法或许是使用定点算数运算。当值的范围足够小定点算数操作比浮点运算更精确、更快速。其他技巧通常可以使用空间换时间。如果你能缓存经常用的数据而不是重新计算这便能更快的访问。比如sine和cosine查找表或者伪随机数。尽量不在循环中使用和–。例如while(n–){}这有时难于优化。减少全局变量的使用。除非像声明为全局变量使用static修饰变量为文件内访问。尽可能使用一个字大小的变量int、long等使用它们而不是charshortdouble位域等机器可能运行的更快。不使用递归。递归可能优雅而简单但需要太多的函数调用。不在循环中使用sqrt开平方函数计算平方根非常消耗性能。一维数组比多维数组更快。编译器可以在一个文件中进行优化-避免将相关的函数拆分到不同的文件中如果将它们放在一起编译器可以更好的处理它们例如可以使用inline。单精度函数比双精度更快。浮点乘法运算比浮点除法运算更快-使用val*0.5而不是val/2.0。加法操作比乘法快-使用valvalval而不是val*3。put()函数比printf()快但不灵活。使用#define宏取代常用的小函数。二进制/未格式化的文件访问比格式化的文件访问更快因为程序不需要在人为可读的ASCII和机器可读的二进制之间转化。如果你不需要阅读文件的内容将它保存为二进制。如果你的库支持mallopt()函数用于控制malloc尽量使用它。MAXFAST的设置对于调用很多次malloc工作的函数由很大的性能提升。如果一个结构一秒钟内需要多次创建并销毁试着设置mallopt选项。最后但是是最重要的是-将编译器优化选项打开看上去很显而易见但却经常在产品推出时被忘记。编译器能够在更底层上对代码进行优化并针对目标处理器执行特定的优化处理。*声明本文于网络整理版权归原作者所有如来源信息有误或侵犯权益请联系我们删除或授权事宜。戳“阅读原文”我们一起进步
