前言

这里记录一些在使用C++进行编程时，可以提高软件性能的小技巧。

文章目录

前言
技巧一
技巧二
技巧三
技巧四
技巧五
技巧六
技巧七
技巧八
技巧九
技巧十
技巧十一
技巧十二
技巧十三
技巧十四
技巧十五
总结
参考资料

程序员对C++的性能有几个公认的基本原则：
①I/O的开销是高昂的；
②函数调用的开销是要考虑的一个因素，因此我们应该将短小的、频繁调用的函数内联；
③复制对象的开销是高昂的，最好选择传递引用，而不是传递值。
性能差的代码示例：

class Trace {
public:Trace(const string &name);~Trace();void debug(const string &msg);static bool traceIsActive;
private:string theFunctionName;
};
inline Trace::Trace(const string &name) : theFunctionName(name) {if (traceIsActive) {cout << “Enter function ” << name << endl;}
}
inline void Trace::debug(const string &msg) {if (traceIsActive) {cout << msg << endl;}
}
inline Trace::~Trace() {if (traceIsActive) {cout << “Exit function ” << theFunctionName << endl;}
}
int myFunction(int x) {string name = “myFunction”;Trace t(name);...string moreInfo = “more interesting info”;t.debug(moreInfo);...
}; // 跟踪析构函数 将退出事件记录到一个输出流中

性能优化改进后的代码示例：

class Trace {
public:Trace(const char *name); // char *要快于string~Trace();void debug(const char *msg);static bool traceIsActive;
private:string *theFunctionName;
};
inline Trace::Trace(const char *name) : theFunctionName(0) {if (traceIsActive) {cout << “Enter function ” << name << endl;theFunctionName = new string(name);}
}
inline void Trace::debug(const char *msg) {if (traceIsActive) {cout << msg << endl;}
}
inline Trace::~Trace() {if (traceIsActive) {cout << “Exit function ” << theFunctionName << endl;delete theFunctionName;}
}

对象定义会触发隐形地执行构造函数和析构函数。对象的构造和销毁并不总是意味产生开销，如果构造函数和析构函数所执行的计算是必须的，那么就要考虑使用高效的代码（内联会减少函数调用和返回的开销）。

技巧一

如果我们不需要用string对象的强大功能去做高深的事情，则完全可以将它替换为char指针，一个char指针的构造比一个string对象廉价的多。

技巧二

对于类的复合对象，为了对子对象的创建和销毁进行更好的控制，可以用指针来代替它。但如果使用模式是跟踪永远打开，则将子对象嵌入到主对象中，效率将会更高，因为它占用的是栈内存而不是堆内存。堆内存的分配与释放代价是相当高昂的，基于栈的内存在编译时分配，而在函数调用返回时的堆栈清除阶段被释放。

技巧三

简化封装。对象的创建（或销毁）触发对父对象和成员对象的递归创建（或销毁），它们使得创建和销毁的开销更高昂。

技巧四

编译器必须初始化被包含的成员对象之后再执行构造函数体。你必须在初始化阶段完成成员对象的创建，这可以降低随后在构造函数部分调用赋值操作符的开销。在某些情况下，这样也可以避免临时对象的产生。

技巧五

未利用RVO进行性能优化的示例：

Complex operator+(const Complex &a, const Complex &b) {Complex retVal;retVal.real = a.real + b.real;retVal.imag = a.imag + b.imag;return retVal;
}

利用RVO进行性能优化的示例：

Complex operator+(const Complex &a, const Complex &b) {double r = a.real + b.real;double i = a.imag + b.imag;return Complex(r, i);
}

即避免不必要的临时变量。

技巧六

临时对象会以构造函数和析构函数的形式降低一半的性能。
例1，不好的写法：

Rational r2 = Rational(100);
Rational r3 = 100;

好的写法：

Rational r1(100);

例2，不好的写法：

string s1 = “Hello”;
string s2 = “World”;
string s3;
s3 = s1 + s2;

好的写法：

string s1 = “Hello”;
string s2 = “World”;
string s3 = s1 + s2;

例3，不好的写法：

s5 = s1 + s2 + s3 + s4; // 产生3个临时对象

好的写法：

s5 = s1;
s5 += s2;
s5 += s3;
s5 += s4;

技巧七

如果主要分配限于单线程的内存块，那么内存管理器也会有类似的性能提高。由于省去了全局函数new()和delete()必须处理的并发问题，单线程内存管理器的性能会有所提高。

// 用来把不同大小的内存块连接起来形成块序列的类
class MemoryChunk {
public:MemoryChunk(MemoryChunk *nextChunk, size_t chunkSize);~MemoryChunk();inline void *alloc(size_t size);inline void free(void *someElement);// 指向列表下一内存块的指针MemoryChunk *nextMemChunk() {return next;}// 当前内存块剩余空间大小size_t spaceAvailable() {return chunkSize - bytesAlreadyAllocated;}// 这是一个内存块的默认大小enum { DEFAULT_CHUNK_SIZE = 4096 };
private:MemoryChunk *next;void *mem;// 一个内存块的默认大小size_t chunkSize;// 当前内存块中已分配的字节数size_t bytesAlreadyAllocated;
};
MemoryChunk::MemoryChunk(MemoryChunk *nextChunk, size_t reqSize) {chunkSize = (reqSize > DEFAULT_CHUNK_SIZE) ? reqSize : DEFAULT_CHUNK_SIZE;next = nextChunk;bytesAlreadyAllocated = 0;mem = new char[chunkSize];
}
MemoryChunk::~MemoryChunk() {delete [] mem;
}
void *MemoryChunk::alloc(size_t requestSize) {void *addr = static_cast<void*>(static_cast<size_t>mem + bytesAlreadyAllocated);bytesAlreadyAllocated += requestSize;return addr;
}
inline void MemoryChunk::free(void *someElement) {}
// 用来实现可变大小内存管理的类
class ByteMemoryPool {
public:ByteMemoryPool(size_t initSize=MemoryChunk::DEFAULT_CHUNK_SIZE);~ByteMemoryPool();// 从私有内存池分配内存inline void *alloc(size_t size);// 释放先前从内存池中分配的内存inline void free(void *someElement);
private:// 内存块列表 它是我们的私有存储空间MemoryChunk *listOfMemoryChunks;// 向我们的私有存储空间添加一个内存块void expandStorage(size_t reqSize); 
};
ByteMemoryPool::ByteMemoryPool(size_t initSize) {expandStorage(initSize);
}
ByteMemoryPool::~ByteMemoryPool() {MemoryChunk *memChunk = listOfMemoryChunks;while (memChunk) {listOfMemoryChunks = memChunk->nextMemChunk();delete memChunk;memChunk = listOfMemoryChunks;}
}
void *ByteMemoryPool::alloc(size_t requestSize) {size_t space = listOfMemoryChunks->spaceAvailable();if (space < requestSize) {expandStorage(requestSize);}return listOfMemoryChunks->alloc(requestSize);
}
inline void ByteMemoryPool::free(void *someElement) {listOfMemoryChunks->free(someElement);
}
void ByteMemoryPool::expandStorage(size_t reqSize) {listOfMemoryChunks = new MemoryChunk(listOfMemoryChunks, reqSize);
}
// 测试内存管理器效果的类
class Rational {
public:Rational(int a=0, int b=1) : n(a), d(b) {}void *operator new(size_t size) {return memPool->alloc(size);}void operator delete(void *doomed, size_t size) {memPool->free(doomed);}static void newMemPool() {memPool = new ByteMemoryPool;}static void deleteMemPool() {delete memPool;}
private:int n; // 分子 int d; // 分母static ByteMemoryPool *memPool;
};
// 测试实际代码
MemoryPool<Rational> *Rational::memPool = 0;
int main() {...Rational *array[1000];Rational::newMemPool();// 此处开始计时for (int j=0; j<500; j++) {for (int i=0; i<1000; i++) {array[i] = new Rational(i);}for (int i=0; i<1000; i++) {delete array[i];}}// 此处停止计时Rational::deleteMemPool();...
}

因为单线程内存管理器要比多线程内存管理器快得多，所以如果要分配的大多数内存块限于单线程中使用，那么可以显著提升性能。
书中给出的多线程内存管理器，由于涉及模板和系统平台特有功能函数的使用，没有借鉴价值。

技巧八

使用内联有时会适得其反，尤其是滥用的情况下。内联可能会使代码量变大，而代码量增多后会较原先出现更多的缓存失败和页面错误。
所以傻瓜式的方法是不要人工指定函数内联，完全交给编译器进行优化。

技巧九

当向vector插入大量自定义类型对象时，对象的拷贝构造函数和析构函数开销相当昂贵，并且向量的容量很有可能继续增长，这时可通过保存指针而不是对象来身份避免这种昂贵的代价。这是因为对象指针没有相关的构造函数和析构函数，复制指针的代价本质上和复制整数是相同的。例如：

vector<BigInt*> v;
v->push_back(new BigInt{10});

技巧十

在很多情况下，我们可以对在特定情况下要尽可能足够大的向量容量进行估计。在你有把握做出恰当估计的情况下，我们可以预留好必要的容量，例如：

vector<BigInt> *v = new vector<BigInt>;
v->reserve(size);
vectorInsert(v, dataBigInt, size);

技巧十一

当访问数据时，最先搜索的是数据缓存。若数据不在缓存中，硬件产生缓存失败信号，该信号会从RAM或硬盘加载数据至缓存中。缓存以缓存行为单位，通常加载比我们所寻找的特定数据项更大的一块数据。这样的话，在4字节整数上的缓存失败可能导致加载128字节的缓存行到缓存中。由于相关数据项的位置在内存中很可能相邻，因此这对我们很有用。
一个没有充分利用缓存行的示例：

class X {
public:X() : a(1), c(2) {}...
private:int a;char b[4096]; // 缓冲区int c;
};

利用缓存行的示例：

class X {...
private:int a;int c;char b[4096];
};

现在a和c更有可能位于相同的缓存行，因为a在c之前被访问，所以当我们需要访问c的时候，基本可以保证c在数据缓存中。

技巧十二

动态分配和释放堆内存的代价比较昂贵。从性能角度来讲，使用不需要显式管理的内存所产生的代价要低得多。被定义成局部变量的对象存放于堆栈上。该对象所占用的堆栈空间是为相应函数预留的堆栈空间的一部分，该对象被定义在这个函数范围内。
一个不好的示例：

void f() {X *xPtr = new X;...delete xPtr;
}

一个更好的示例，定义类型X的局部对象：

void f() {X x;...
} // 不需要释放x的内存

在后一种实现中，对象x驻留在堆栈上，因而不需要事先为其分配内存，也不需要在函数退出时释放内存。当f()返回时，堆栈内存会自动释放，这样就避免了调用new()和delete()的巨大代价。
成员数据中也存在类似的问题，但这次不是堆和栈内存之间的问题，而是选择将指针还是整个对象嵌入到包含对象中的问题。
一个不好的示例：

class Z {
public:Z() : xPtr(new X) { ... }~Z() { delete xPtr; }
private:X *xPtr;...
};

在构造函数中调用new()和在析构函数中调用delete()所产生的开销明显地增加了对象Z的代价。
一个更好的示例，在Z中嵌入对象X来消除内存管理的代价：

class Z {
public:Z() { ... }~Z() { ... }
private:X x;...
};

技巧十三

通常情况下，编译器默认根本不会进行任何优化，这意味着这些重要的性能优化将不会生效，即使在代码中使用了关键字register和inline也无济于事。编译器会自动忽略这些关键字，而且它经常这样做。为了更好地利用这些优化手段，必须通过向命令行添加开关-O或者在GUI界面上选择性能优化选项。

技巧十四

缓存的原子单元以行为单位，一般来说一个缓存行可以存储大量字节，典型的缓存行有128字节。当从主内存加载4字节的整数时，并不是仅加载这4个字节，而是把包含它的整个行立即加载到缓存。当另外的缓存（在不同的处理器上运行）使这个整数无效时，整个缓存行都是无效的。因此，变量在物理内存中的布局十分重要。例如，HTStats类如果去掉smpDmz字符数组，会使两个锁相互靠近：

class HTStats {int httpReqs;int httpBytes; pthread_mutex_t lockHttp;char smpDmz[CACHE_LINE_SIZE];int sslReqs;int sslBytes;pthread_mutex_t lockSsl;...
};

两个锁lockHttp和lockSsl只相距8字节，它们很可能驻留在同一缓存行上。在P1和P2上运行的线程将不断使对方驻留的两个锁的缓存行失效。缓存一致性风暴将会严重降低性能和可扩展性，同时缓存命中率会降低到90%以下。而插入smpDmz字符数组可保证两个锁不会共享缓存行。理想情况下，锁应该放置在最靠近它所保护的共享数据附近。