C++优化考虑

一. 优化之前
在进行优化之前，我们首先应该做的是发现我们代码的瓶颈（bottleneck）在哪里。然而当你做这件事情的时候切忌从一个debug-version进行推断，因为debug-version中包含了许多额外的代码。一个debug-version可执行体要比release-version大出40%。那些额外的代码都是用来支持调试的，比如说符号的查找。大多数实现都为debug-version和release-version提供了不同的operator new以及库函数。而且，一个release-version的执行体可能已经通过多种途径进行了优化，包括不必要的临时对象的消除，循环展开，把对象移入寄存器，内联等等。
另外，我们要把调试和优化区分开来，它们是在完成不同的任务。 debug-version 是用来追捕bugs以及检查程序是否有逻辑上的问题。release-version则是用来做一些性能上的调整以及进行优化。
下面就让我们来看看有哪些代码优化技术吧：

二. 声明的放置
程序中变量和对象的声明放在什么位置将会对性能产生显著影响。同样，对postfix和prefix运算符的选择也会影响性能。这一部分我们集中讨论四个问题：初始化v.s 赋值，在程序确实要使用的地方放置声明，构造函数的初始化列表，prefix v.s postfix运算符。
（1） 请使用初始化而不是赋值
在C语言中只允许在一个函数体的开头进行变量的声明，然而在C++中声明可以出现在程序的任何位置。这样做的目的是希望把对象的声明拖延到确实要使用它的时候再进行。这样做可以有两个好处：1. 确保了对象在它被使用前不会被程序的其他部分恶意修改。如果对象在开头就被声明然而却在20行以后才被使用的话，就不能做这样的保证。2. 使我们有机会通过用初始化取代赋值来达到性能的提升，从前声明只能放在开头，然而往往开始的时候我们还没有获得我们想要的值，因此初始化所带来的好处就无法被应用。但是现在我们可以在我们获得了想要的值的时候直接进行初始化，从而省去了一步。注意，或许对于基本类型来说，初始化和赋值之间可能不会有什么差异，但是对于用户定义的类型来说，二者就会带来显著的不同，因为赋值会多进行一次函数调用----operator =。因此当我们在赋值和初始化之间进行选择的话，初始化应该是我们的首选。
（2） 把声明放在合适的位置上
在一些场合，通过移动声明到合适的位置所带来的性能提升应该引起我们足够的重视。例如：
bool is_C_Needed();
void use()
{
C c1;
if (is_C_Needed() == false)
{
return; //c1 was not needed
}
//use c1 here
return;
}
上面这段代码中对象c1即使在有可能不使用它的情况下也会被创建，这样我们就会为它付出不必要的花费，有可能你会说一个对象c1能浪费多少时间，但是如果是这种情况呢：C c1[1000];我想就不是说浪费就浪费了。但是我们可以通过移动声明c1的位置来改变这种情况：
void use()
{
if (is_C_Needed() == false)
{
return; //c1 was not needed
}
C c1; //moved from the block's beginning
//use c1 here
return;
}
怎么样，程序的性能是不是已经得到很大的改善了呢？因此请仔细分析你的代码，把声明放在合适的位置上，它所带来的好处是你难以想象的。
（3） 初始化列表
我们都知道，初始化列表一般是用来初始化const或者reference数据成员。但是由于他自身的性质，我们可以通过使用初始化列表来实现性能的提升。我们先来看一段程序：
class Person
{
private:
C c_1;
C c_2;
public:
Person(const C& c1, const C& c2 ): c_1(c1), c_2(c2) {}
};
当然构造函数我们也可以这样写：
Person::Person(const C& c1, const C& c2)
{
c_1 = c1;
c_2 = c2;
}
那么究竟二者会带来什么样的性能差异呢，要想搞清楚这个问题，我们首先要搞清楚二者是如何执行的，先来看初始化列表：数据成员的声明操作都是在构造函数执行之前就完成了，在构造函数中往往完成的只是赋值操作，然而初始化列表直接是在数据成员声明的时候就进行了初始化，因此它只执行了一次copy constructor。再来看在构造函数中赋值的情况：首先，在构造函数执行前会通过default constructor创建数据成员，然后在构造函数中通过operator =进行赋值。因此它就比初始化列表多进行了一次函数调用。性能差异就出来了。但是请注意，如果你的数据成员都是基本类型的话，那么为了程序的可读性就不要使用初始化列表了，因为编译器对两者产生的汇编代码是相同的。
（4） postfix VS prefix 运算符
prefix运算符++和—比它的postfix版本效率更高，因为当postfix运算符被使用的时候，会需要一个临时对象来保存改变以前的值。对于基本类型，编译器会消除这一份额外的拷贝，但是对于用户定义类型，这似乎是不可能的。因此请你尽可能使用prefix运算符。

三. 内联函数
内联函数既能够去除函数调用所带来的效率负担又能够保留一般函数的优点。然而，内联函数并不是万能药，在一些情况下，它甚至能够降低程序的性能。因此在使用的时候应该慎重。
1．我们先来看看内联函数给我们带来的好处：从一个用户的角度来看，内联函数看起来和普通函数一样，它可以有参数和返回值，也可以有自己的作用域，然而它却不会引入一般函数调用所带来的负担。另外，它可以比宏更安全更容易调试。
当然有一点应该意识到，inline specifier仅仅是对编译器的建议，编译器有权利忽略这个建议。那么编译器是如何决定函数内联与否呢？一般情况下关键性因素包括函数体的大小，是否有局部对象被声明，函数的复杂性等等。
2．那么如果一个函数被声明为inline但是却没有被内联将会发生什么呢？理论上，当编译器拒绝内联一个函数的时候，那个函数会像普通函数一样被对待，但是还会出现一些其他的问题。例如下面这段代码：
// filename Time.h
#include<ctime>
#include<iostream>
using namespace std;
class Time
{
public:
inline void Show() { for (int i = 0; i<10; i++) cout<<time(0)<<endl;}
};
因为成员函数Time::Show()包括一个局部变量和一个for循环，所以编译器一般拒绝inline，并且把它当作一个普通的成员函数。但是这个包含类声明的头文件会被单独的#include进各个独立的编译单元中：
// filename f1.cpp
#include "Time.hj"
void f1()
{
Time t1;
t1.Show();
}

// filename f2.cpp
#include "Time.h"
void f2()
{
Time t2;
t2.Show();
}
结果编译器为这个程序生成了两个相同成员函数的拷贝：
void f1();
void f2();
int main()
{
f1();
f2();
return 0;
}
当程序被链接的时候，linker将会面对两个相同的Time::Show()拷贝，于是函数重定义的连接错误发生。但是老一些的C++实现对付这种情况的办法是通过把一个un-inlined函数当作static来处理。因此每一份函数拷贝仅仅在自己的编译单元中可见，这样链接错误就解决了，但是在程序中却会留下多份函数拷贝。在这种情况下，程序的性能不但没有提升，反而增加了编译和链接时间以及最终可执行体的大小。
但是幸运的是，新的C++标准中关于un-inlined函数的说法已经改变。一个符合标准C++实现应该只生成一份函数拷贝。然而，要想所有的编译器都支持这一点可能还需要很长时间。
另外关于内联函数还有两个更令人头疼的问题。第一个问题是该如何进行维护。一个函数开始的时候可能以内联的形式出现，但是随着系统的扩展，函数体可能要求添加额外的功能，结果内联函数就变得不太可能，因此需要把inline specifier去除以及把函数体放到一个单独的源文件中。另一个问题是当内联函数被应用在代码库的时候产生。当内联函数改变的时候，用户必须重新编译他们的代码以反映这种改变。然而对于一个非内联函数，用户仅仅需要重新链接就可以了。
这里想要说的是，内联函数并不是一个增强性能的灵丹妙药。只有当函数非常短小的时候它才能得到我们想要的效果，但是如果函数并不是很短而且在很多地方都被调用的话，那么将会使得可执行体的体积增大。最令人烦恼的还是当编译器拒绝内联的时候。在老的实现中，结果很不尽人意，虽然在新的实现中有很大的改善，但是仍然还是不那么完善的。一些编译器能够足够的聪明来指出哪些函数可以内联哪些不能，但是，大多数编译器就不那么聪明了，因此这就需要我们的经验来判断。如果内联函数不能增强行能，就避免使用它！

四. 优化你的内存使用
通常优化都有几个方面：更快的运行速度，有效的系统资源使用，更小的内存使用。一般情况下，代码优化都是试图在以上各个方面进行改善。重新放置声明技术被证明是消除多余对象的建立和销毁，这样既减小了程序的大小又加快了运行速度。然而其他的优化技术都是基于一个方面------更快的速度或者是更小的内存使用。有时，这些目标是互斥的，压缩了内存的使用往往却减慢了代码速度，快速的代码却又需要更多的内存支持。下面总结两种在内存使用上的优化方法：
1． Bit Fields
在C/C++中都可以存取和访问数据的最小组成单元：bit。因为bit并不是C/C++基本的存取单元，所以这里是通过牺牲运行速度来减少内存和辅助存储器的空间的使用。注意：一些硬件结构可能提供了特殊的处理器指令来存取bit，因此bit fields是否影响程序的速度取决于具体平台。
在我们的现实生活中，一个数据的许多位都被浪费了，因为某些应用根本就不会有那么大的数据范围。也许你会说，bit是如此之小，通过它就能减小存储空间的使用吗？的确，在数据量很小的情况下不会看出什么效果，但是在数据量惊人的情况下，它所节省的空间还是能够让我们的眼睛为之一亮的。也许你又会说，现在内存和硬盘越来越便宜，何苦要费半天劲，这省不了几个钱。但是还有另外一个原因一定会使你信服，那就是数字信息传输。一个分布式数据库都会在不同的地点有多份拷贝。那么数百万的纪录传输就会显得十分昂贵。Ok，现在我们就来看看该如何做吧，首先看下面这段代码：
struct BillingRec
{
long cust_id;
long timestamp;
enum CallType
{
toll_free,
local,
regional,
long_distance,
international,
cellular
} type;
enum CallTariff
{
off_peak,
medium_rate,
peak_time
} tariff;
};
上面这个结构体在32位的机器上将会占用16字节，你会发现其中有许多位都被浪费了，尤其是那两个enum型，浪费更是严重，所以请看下面做出的改进：
struct BillingRec
{
int cust_id: 24; // 23 bits + 1 sign bit
int timestamp: 24;
enum CallType
{//...
};
enum CallTariff
{//...
};
unsigned call: 3;
unsigned tariff: 2;
};
现在一个数据从16字节缩减到了8字节，减少了一半，怎么样，效果还是显著的吧：）
2． Unions
Unions通过把两个或更多的数据成员放置在相同地址的内存中来减少内存浪费，这就要求在任何时间只能有一个数据成员有效。Union 可以有成员函数，包括构造函数和析构函数，但是它不能有虚函数。C++支持anonymous unions。anonymous union是一个未命名类型的未命名对象。例如：
union { long n; void * p}; // anonymous
n = 1000L; // members are directly accessed
p = 0; // n is now also 0
不像命名的union，它不能有成员函数以及非public的数据成员。
那么unions什么时候是有用的呢？下面这个类从数据库中获取一个人的信息。关键字既可以是一个特有的ID或者人名，但是二者却不能同时有效：
class PersonalDetails
{
private:
char * name;
long ID;
//...
public:
PersonalDetails(const char *nm); //key is of type char * used
PersonalDetails(long id) : ID(id) {} //numeric key used
};
上面这段代码中就会造成内存的浪费，因为在一个时间只能有一个关键字有效。anonymous union可以在这里使用来减少内存的使用，例如：
class PersonalDetails
{
private:
union //anonymous
{
char * name;
long ID;
};
public:
PersonalDetails(const char *nm);
PersonalDetails(long id) : ID(id) {/**/} // direct access to a member
//...
};
通过使用union，PersonalDetails类的大小被减半。但是这里要说明的是，节省4 个字节内存并不值得引入union所带来的麻烦，除非这个类作为数百万数据库记录的类型或者纪录在一条很慢的通信线路传输。值得注意的是unions并不引入任何运行期负担，所以这里不会有什么速度上的损失。anonymous union的优点就是它的成员可以被直接访问。
五. 速度优化
在一些对速度要求非常苛刻的应用系统中，每一个CPU周期都是要争取的。这个部分展现了一些简单方法来进行速度优化。
1． 使用类来包裹长的参数列表
一个函数调用的负担将会随着参数列表的增长而增加。运行时系统不得不建立堆栈来存储参数值；通常，当参数很多的时候，这样一个操作就会花费很长的时间。
把参数列表包裹进一个单独的类中并且通过引用进行传递，这样将会节省很多的时间。当然，如果函数本身就很长，那么建立堆栈的时间就可以忽略了，因此也就没有必要这样做。然而，对于那些执行时间很短而且经常被调用的函数来说，包裹一个长的参数列表在对象中并且通过引用传递将会提高性能。
2． 寄存器变量
register specifier被用来告诉编译器一个对象将被会非常多的使用，可以把它放入寄存器中。例如：
void f()
{
int *p = new int[3000000];
register int *p2 = p; //store the address in a register
for (register int j = 0; j<3000000; j++)
{
*p2++ = 0;
}
//...use p
delete [] p;
}
循环计数是应用寄存器变量的最好的候选者。当它们没有被存入一个寄存器中，大部分的循环时间都被用在了从内存中取出变量和给变量赋新值上。如果把它存入一个寄存器中的话，将会大大减少这种负担。需要注意的是，register specifier仅仅是对编译器的一个建议。就好比内联函数一样，编译器可以拒绝把一个对象存储到寄存器中。另外，现代的编译器都会通过把变量放入寄存器中来优化循环计数。Register storage specifier并不仅仅局限在基本类型上，它能够被应用于任何类型的对象。如果对象太大而不能装进寄存器的话，编译器仍然能够把它放入一个高速存储器中，例如cache。
用register storage specifier声明函数型参将会是建议编译器把实参存入寄存器中而不是堆栈中。例如：

void f(register int j, register Date d);

3． 把那些保持不变的对象声明为const
通过把对象声明为const，编译器就可以利用这个声明把这样一个对象放入寄存器中。
4． Virtual function的运行期负担
当调用一个virtual function，如果编译器能够解决调用的静态化，将不会引入额外的负担。另外，一个非常短的虚函数可以被内联处理。在下面这个例子中，一个聪明的编译器能够做到静态调用虚函数：
#include <iostream>
using namespace std;
class V
{
public:
virtual void show() const { cout<<"I'm V"<<endl; }
};
class W : public V
{
public:
void show() const { cout<<"I'm W"<<endl; }
};
void f(V & v, V *pV)
{
v.show();
pV->show();
}
void g()
{
V v;
f(v, &v);
}
int main()
{
g();
return 0;
}
如果整个程序出现在一个单独的编译单元中，编译器能够对main()中的g()进行内联替换。并且在g()中f()的调用也能够被内联处理。因为传给f()的参数的动态类型能够在编译期被知晓，因此编译器能够把对虚函数的调用静态化。但是不能保证每个编译器都这样做。然而，一些编译器确实能够利用在编译期获得参数的动态类型从而使得函数的调用在编译期间就确定了下来，避免了动态绑定的负担。
5． Function objects VS function pointers
用function objects取代function pointers的好处不仅仅局限在能够泛化和简单的维护性上。而且编译器能够对function object的函数调用进行内联处理，从而进一步的增强了性能
六. 最后的求助
迄今为止为大家展示的优化技术并没有在设计以及代码的可读性上做出妥协。事实上，它们中的一些还提高了软件的稳固性和可维护性。但是在一些对时间和内存有严格限制的软件开发中，上面的技术可能还不够；有可能还需要一些会影响软件的可移植性和扩展性的技术。但是这些技术只能在所有其他的优化技术都被应用但是还不符合要求的情况下使用。
1． 关闭RTTI和异常处理支持
当你导入纯C代码给C++编译器的时候，你可能会发现有一些性能上的损失。这并不是语言或者编译器的错误，而是编译器作出的一些调整。如果你想获得和C编译器同样的性能，那么请关闭编译器对RTTI以及异常处理的支持。为什么会这样呢？因为为了支持RTTI和异常处理，C++编译器会插入额外的代码。这样就增加了可执行体的大小，从而使得效率有所下降。当应用纯C代码的时候，那些额外的代码是不需要的，所以你可以通过关闭来避免它。
2． 内联汇编
对时间要求苛刻的部分可以用本地汇编来重写。结果可能是速度上的显著提高。然而，这个方法不能想当然的就去实施，因为它将使得将来的修改非常的困难。维护代码的程序员可能对汇编并不了解。如果想要把软件运行于其他平台也需要重写汇编代码部分。另外，开发和测试汇编代码是一件辛苦的工作，它将花费更长的时间。
3． 直接和操作系统进行交互
API函数可以使你直接与操作系统进行交互。有时，直接执行一个系统命令可能会快许多。出于这个目的，你可以使用标准函数system()。例如，在一个dos/windows系统下，你可以这样显示当前目录下的文件：
#include <cstdlib>
using namespace std;
int main()
{
system("dir"); //execute the "dir" command
}
注意：这里是在速度和可移植性以及可扩展性之间做出的折衷。

 

1.确定浮点型变量和表达式是 float 型
    为了让编译器产生更好的代码(比如说产生3DNow! 或SSE指令的代码)，必须确定浮点型变量和表达式是 float 型的。要特别注意的是，以 "；F"； 或 "；f"； 为后缀（比如：3.14f）的浮点常量才是 float 型，否则默认是 double 型。为了避免 float 型参数自动转化为 double，请在函数声明时使用 float。
2.使用32位的数据类型
　　编译器有很多种，但它们都包含的典型的32位类型是：int，signed，signed int，unsigned，unsigned int，long，signed long，long int，signed long int，unsigned long，unsigned long int。尽量使用32位的数据类型，因为它们比16位的数据甚至8位的数据更有效率。
3.明智使用有符号整型变量
　　在很多情况下，你需要考虑整型变量是有符号还是无符号类型的。比如，保存一个人的体重数据时不可能出现负数，所以不需要使用有符号类型。但是，如果是要保存温度数据，就必须使用到有符号的变量。
　　在许多地方，考虑是否使用有符号的变量是必要的。在一些情况下，有符号的运算比较快；但在一些情况下却相反。
　　比如：整型到浮点转化时，使用大于16位的有符号整型比较快。因为x86构架中提供了从有符号整型转化到浮点型的指令，但没有提供从无符号整型转化到浮点的指令。看看编译器产生的汇编代码：
　　不好的代码：
编译前      编译后
double x；    mov [foo + 4], 0
unsigned int i；   mov eax, i
x = i；     mov [foo], eax
     flid qword ptr [foo]
     fstp qword ptr [x]
　　上面的代码比较慢。不仅因为指令数目比较多，而且由于指令不能配对造成的FLID指令被延迟执行。最好用以下代码代替：
    推荐的代码：
编译前     编译后
double x；    fild dword ptr
int i；     fstp qword ptr [x]
x = i；
　　在整数运算中计算商和余数时，使用无符号类型比较快。以下这段典型的代码是编译器产生的32位整型数除以4的代码：
　　不好的代码 
编译前      编译后
int i；     mov eax, i
i = i / 4；     cdq
     and edx, 3
     add eax, edx
     sar eax, 2
     mov i, eax
    推荐的代码
编译前      编译后
unsigned int i；    shr i, 2
i = i / 4；
　总结：
　无符号类型用于：除法和余数,循环计数,数组下标
  有符号类型用于：整型到浮点的转化
4.while VS. for
　　在编程中，我们常常需要用到无限循环，常用的两种方法是while (1) 和 for (；；)。这两种方法效果完全一样，但那一种更好呢？然我们看看它们编译后的代码：
编译前      编译后
while (1)；     mov eax,1
     test eax,eax
     je foo+23h
     jmp foo+18h
编译前      编译后 
for (；；)；     jmp foo+23h
　　一目了然，for (；；)指令少，不占用寄存器，而且没有判断跳转，比while (1)好。
5.使用数组型代替指针型
　　使用指针会使编译器很难优化它。因为缺乏有效的指针代码优化的方法，编译器总是假设指针可以访问内存的任意地方，包括分配给其他变量的储存空间。所以为了编译器产生优化得更好的代码，要避免在不必要的地方使用指针。一个典型的例子是访问存放在数组中的数据。C++ 允许使用操作符 [] 或指针来访问数组，使用数组型代码会让优化器减少产生不安全代码的可能性。比如，x[0] 和x[2] 不可能是同一个内存地址，但 *p 和 *q 可能。强烈建议使用数组型，因为这样可能会有意料之外的性能提升。
    不好的代码
typedef struct
{
　　float x,y,z,w；
} VERTEX；
typedef struct

{
　　float m[4][4]；
} MATRIX；
void XForm(float* res, const float* v, const float* m, int nNumVerts)
{
　　float dp；
　　int i；
　　　const VERTEX* vv = (VERTEX *)v；
　　　for (i = 0； i <； nNumVerts； i++)
　　{
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　　　// 写入转换了的 x
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　　// 写入转换了的 y
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　// 写入转换了的 z
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　// 写入转换了的 w
　　　　vv ++；　　　　　　　 // 下一个矢量
　　　　m -= 16；
　　}
}
    推荐的代码
typedef struct
{
　　float x,y,z,w；
} VERTEX；
typedef struct
{
　　float m[4][4]；
} MATRIX；
void XForm (float* res, const float* v, const float* m, int nNumVerts)
{
　　int i；
　　const VERTEX* vv = (VERTEX*)v；
　　const MATRIX* mm = (MATRIX*)m；
　　VERTEX* rr = (VERTEX*)res；
　　for (i = 0； i <； nNumVerts； i++)
　　{
　　　　rr->；x = vv->；x * mm->；m[0][0] + vv->；y * mm->；m[0][1]
　　　　　　　　+ vv->；z * mm->；m[0][2] + vv->；w * mm->；m[0][3]；
　　　　rr->；y = vv->；x * mm->；m[1][0] + vv->；y * mm->；m[1][1]
　　　　　　　　+ vv->；z * mm->；m[1][2] + vv->；w * mm->；m[1][3]；
　　　　rr->；z = vv->；x * mm->；m[2][0] + vv->；y * mm->；m[2][1]
　　　　　　　　+ vv->；z * mm->；m[2][2] + vv->；w * mm->；m[2][3]；
　　　　rr->；w = vv->；x * mm->；m[3][0] + vv->；y * mm->；m[3][1]
　　　　　　　　+ vv->；z * mm->；m[3][2] + vv->；w * mm->；m[3][3]；
　　}
}
　　注意: 源代码的转化是与编译器的代码发生器相结合的。从源代码层次很难控制产生的机器码。依靠编译器和特殊的源代码，有可能指针型代码编译成的机器码比同等条件下的数组型代码运行速度更快。明智的做法是在源代码转化后检查性能是否真正提高了，再选择使用指针型还是数组型。
6.充分分解小的循环
　　要充分利用CPU的指令缓存，就要充分分解小的循环。特别是当循环体本身很小的时候，分解循环可以提高性能。BTW:很多编译器并不能自动分解循环。
不好的代码 推荐的代码
// 3D转化：把矢量 V 和 4x4 矩阵 M 相乘
for (i = 0； i <； 4； i ++)
{
　　r = 0；
　　for (j = 0； j <； 4； j ++)
　　{
　　　　r += M[j]*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]；
7.避免没有必要的读写依赖
　　当数据保存到内存时存在读写依赖，即数据必须在正确写入后才能再次读取。虽然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；
}
8.Switch 的用法
　　Switch 可能转化成多种不同算法的代码。其中最常见的是跳转表和比较链/树。推荐对case的值依照发生的可能性进行排序，把最有可能的放在第一个，当switch用比较链的方式转化时，这样可以提高性能。此外，在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；
}
9.所有函数都应该有原型定义
　　一般来说，所有函数都应该有原型定义。原型定义可以传达给编译器更多的可能用于优化的信息。
　　尽可能使用常量(const)。C++ 标准规定，如果一个const声明的对象的地址不被获取，允许编译器不对它分配储存空间。这样可以使代码更有效率，而且可以生成更好的代码。
10.提升循环的性能
　　要提升循环的性能，减少多余的常量计算非常有用（比如，不随循环变化的计算）。
　　不好的代码(在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()的值，这样可以避免重复计算。虽然不好的代码中的分支可以简单地预测，但是由于推荐的代码在进入循环前分支已经确定，就可以减少对分支预测的依赖。 　　把本地函数声明为静态的(static)
　　如果一个函数在实现它的文件外未被使用的话，把它声明为静态的(static)以强制使用内部连接。否则，默认的情况下会把函数定义为外部连接。这样可能会影响某些编译器的优化——比如，自动内联。
11.考虑动态内存分配
　　动态内存分配（C++中的"；new"；）可能总是为长的基本类型（四字对齐）返回一个已经对齐的指针。但是如果不能保证对齐，使用以下代码来实现四字对齐。这段代码假设指针可以映射到 long 型。
　　例子
　　double* p = (double*)new BYTE[sizeof(double) * number_of_doubles+7L]；
    double* np = (double*)((long(p) + 7L) &； –8L)；
　　现在，你可以使用 np 代替 p 来访问数据。注意：释放储存空间时仍然应该用delete p。
12.使用显式的并行代码
　　尽可能把长的有依赖的代码链分解成几个可以在流水线执行单元中并行执行的没有依赖的代码链。因为浮点操作有很长的潜伏期，所以不管它被映射成 x87 或 3DNow! 指令，这都很重要。很多高级语言，包括C++，并不对产生的浮点表达式重新排序，因为那是一个相当复杂的过程。需要注意的是，重排序的代码和原来的代码在代数上一致并不等价于计算结果一致，因为浮点操作缺乏精确度。在一些情况下，这些优化可能导致意料之外的结果。幸运的是，在大部分情况下，最后结果可能只有最不重要的位（即最低位）是错误的。
　　不好的代码
double a[100], sum；
int i；
sum = 0.0f；
for (i=0； i<；100； i++)
　　sum += a；
    推荐的代码
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；
　　sum2 += a[i+1]；
　　sum3 += a[i+2]；
　　sum4 += a[i+3]；
}
sum = (sum4+sum3)+(sum1+sum2)；
　　要注意的是：使用4 路分解是因为这样使用了4阶段流水线浮点加法，浮点加法的每一个阶段占用一个时钟周期，保证了最大的资源利用率。
13.提出公共子表达式
　　在某些情况下，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；
14.结构体成员的布局
　　很多编译器有“使结构体字，双字或四字对齐”的选项。但是，还是需要改善结构体成员的对齐，有些编译器可能分配给结构体成员空间的顺序与他们声明的不同。但是，有些编译器并不提供这些功能，或者效果不好。所以，要在付出最少代价的情况下实现最好的结构体和结构体成员对齐，建议采取这些方法：
　　A按类型长度排序
　　把结构体的成员按照它们的类型长度排序，声明成员时把长的类型放在短的前面。
　　把结构体填充成最长类型长度的整倍数
　　把结构体填充成最长类型长度的整倍数。照这样，如果结构体的第一个成员对齐了，所有整个结构体自然也就对齐了。下面的例子演示了如何对结构体成员进行重新排序：
　　不好的代码，普通顺序 推荐的代码，新的顺序并手动填充了几个字节
struct
{
　　char a[5]；
　　long k；
　　double x；
} baz；
struct
{
　　double x；
　　long k；
　　char a[5]；
char pad[7]；
} baz；

　　这个规则同样适用于类的成员的布局。
　　B按数据类型的长度排序本地变量
　　当编译器分配给本地变量空间时，它们的顺序和它们在源代码中声明的顺序一样，和上一条规则一样，应该把长的变量放在短的变量前面。如果第一个变量对齐了，其它变量就会连续的存放，而且不用填充字节自然就会对齐。有些编译器在分配变量时不会自动改变变量顺序，有些编译器不能产生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；
14.避免不必要的整数除法
　　整数除法是整数运算中最慢的，所以应该尽可能避免。一种可能减少整数除法的地方是连除，这里除法可以由乘法代替。这个替换的副作用是有可能在算乘积时会溢出，所以只能在一定范围的除法中使用。
　　不好的代码 推荐的代码
int i, j, k, m；
m = i / j / k；
int i, j, k, m；
m = i / (j * k)；
15.把频繁使用的指针型参数拷贝到本地变量
　　避免在函数中频繁使用指针型参数指向的值。因为编译器不知道指针之间是否存在冲突，所以指针型参数往往不能被编译器优化。这样是数据不能被存放在寄存器中，而且明显地占用了内存带宽。注意，很多编译器有“假设不冲突”优化开关（在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；
}
16.赋值与初始化
先看看以下代码：
class CInt
{
　　int m_i；
public:
　　CInt(int a = 0):m_i(a) { cout <；<； "；CInt"； <；<； endl； }
　　~CInt() { cout <；<； "；~CInt"； <；<； endl； }
　　CInt operator + (const CInt&； a) { return CInt(m_i + a.GetInt())； }
　　void SetInt(const int i)　　{ m_i = i； }
　　int GetInt() const　　　　　　{ return m_i； }
}；
    不好的代码
void main()
{
　　CInt a, b, c；
　　a.SetInt(1)；
　　b.SetInt(2)；
　　c = a + b；
}
    推荐的代码
void main()
{
　　CInt a(1), b(2)；
　　CInt c(a + b)；
}
　　这两段代码所作的事都一样，但那一个更好呢？看看输出结果就会发现，不好的代码输出了四个"；CInt"；和四个"；~CInt"；，而推荐的代码只输出三个。也就是说，第二个例子比第一个例子少生成一次临时对象。Why? 请注意，第一个中的c用的是先声明再赋值的方法，第二个用的是初始化的方法，它们有本质的区别。第一个例子的"；c = a + b"；先生成一个临时对象用来保存a + b的值，再把该临时对象用位拷贝的方法给c赋值，然后临时对象被销毁。这个临时对象就是那个多出来的对象。第二个例子直接用拷贝构造函数的方法对c初始化，不产生临时对象。所以，尽量在需要使用一个对象时才声明，并用初始化的方法赋初值。
17.尽量使用成员初始化列表
　　在初始化类的成员时，尽量使用成员初始化列表而不是传统的赋值方式。
　　不好的代码
class CMyClass
{
　　string strName；
public:
　　CMyClass(const string&； str)；
}；
CMyClass::CMyClass(const string&； str)
{
　　strName = str；
}
    推荐的代码
class CMyClass
{
　　string strName；
　　int i；
public:
　　CMyClass(const string&； str)；
}；
CMyClass::CMyClass(const string&；str)
   :strName(str)
{

}
　　不好的例子用的是赋值的方式。这样，strName会先被建立（调用了string的默认构造函数），再由参数str赋值。而推荐的例子用的是成员初始化列表，strName直接构造为str，少调用一次默认构造函数，还少了一些安全隐患。