C++性能优化技术指南

需积分: 50 162 浏览量更新于2024-07-19 收藏 1.56MB PDF 举报

"Efficient C++：性能编程技术" 《Efficient C++》是Dov Bulka和David Mayhew合著的一本关于C++性能优化的书籍，由Addison Wesley出版社于1999年11月3日出版，ISBN为0-201-37950-3，共336页。这本书挑战了普遍认为C++不适合编写高性能应用的观念，展示了C++在性能优化方面的潜力。作者凭借在商业C++应用中榨取最后一点性能的实践经验，揭示了能够带来显著性能提升的实用面向对象设计原则和C++编码技巧。书中不仅指出了在设计和代码编写过程中容易导致隐藏运行成本的常见陷阱，还着重探讨了如何将C++的强大功能和灵活性与高性能及可扩展性相结合，从而达到两全其美的效果。本书涉及的具体话题包括： 1. 临时对象的管理：临时对象的创建和销毁对程序性能有直接影响，书中可能会介绍如何通过优化临时对象的生命周期来提高效率。 2. 构造函数和析构函数的使用：高效C++编程往往需要精心设计对象的构造和析构过程，以减少不必要的资源消耗。 3. 内存管理：包括智能指针的使用、内存池技术以及何时应该手动管理内存以避免内存碎片和性能下降。 4. 静态与动态绑定：静态绑定（编译时绑定）通常比动态绑定（运行时绑定）更快，书中有可能讨论如何合理使用虚函数和模板来平衡这两者。 5. 迭代器的高效使用：在处理容器时，选择合适的迭代器类型和操作方式可以显著提高代码执行速度。 6. 避免不必要的拷贝：通过引用、常量引用和移动语义来减少对象的拷贝，从而提高性能。 7. 多线程编程：C++中的线程同步和并发控制技巧，如何有效利用多核处理器，以及避免竞态条件和死锁。 8. STL的优化：标准模板库（STL）的内部工作原理，如何选择和调整容器、算法和迭代器以获得最佳性能。 9. 对象池和预分配：对于大量短生命周期的对象，使用对象池可以减少内存分配的开销。 10. 内联函数和预编译头文件：如何合理使用内联函数以减少函数调用开销，以及预编译头文件如何加快编译速度。通过学习《Efficient C++》，读者将了解到如何避免常见的性能陷阱，掌握提高C++代码效率的关键技术和策略，使得C++在诸如网络编程、操作系统内核、设备驱动等对性能要求极高的领域也能发挥出强大的作用。

• Create a temporary string object from "x = "

• Call itoa(x)

• Create a temporary string object from the char pointer returned by itoa()

• Concatenate the preceding string objects to create a third temporary string

• Destroy all three string temporaries after returning from the debug() call

So we go to all this trouble to construct three temporary

string objects, and proceed to drop them all

over the floor when we find out that trace is inactive. The overhead of creating and destroying those

string and Trace objects is at best hundreds of instructions. In typical OO code where functions are

short and call frequencies are high, trace overhead could easily degrade performance by an order of

magnitude. This is not a farfetched figment of our imagination. We have actually experienced it in a real-

life product implementation. It is an educational experience to delve into this particular horror story in

more detail. It is the story of an attempt to add tracing capability to a complex product consisting of a half-

million lines of C++ code. Our first attempt backfired due to atrocious performance.

Our Initial Trace Implementation

Our intent was to have the trace object log event messages such as entering a function, leaving a function,

and possibly other information of interest between those two events.

int myFunction(int x)

{

string name = "myFunction";

Trace t(name);

...

string moreInfo = "more interesting info";

t.debug(moreInfo);

...

}; // Trace destructor logs exit event to an output stream

To enable this usage we started out with the following Trace implementation:

class Trace {

public:

Trace (const string &name);

~Trace ();

void debug (const string &msg);

static bool traceIsActive;

private:

string theFunctionName;

};

The Trace constructor stores the function's name.

inline

Trace::Trace(const string &name) : theFunctionName(name)

{

if (TraceIsActive) {

cout << "Enter function" << name << endl;

}

Additional information messages are logged via calls to the debug() method.

inline

void Trace::debug(const string &msg)

{

if (TraceIsActive) {

cout << msg << endl;

}

inline

Trace::~Trace()

{

if (traceIsActive) {

cout << "Exit function " << theFunctionName << endl;

}

Once the Trace was designed, coded, and tested, it was deployed and quickly inserted into a large part of

the code.

Trace objects popped up in most of the functions on the critical execution path. On a subsequent

performance test we were shocked to discover that performance plummeted to 20% of its previous level.

The insertion of

Trace objects has slowed down performance by a factor of five. We are talking about the

case when tracing was off and performance was supposed to be unaffected.

What Went Wrong

Programmers may have different views on C++ performance depending on their respective experiences.

But there are a few basic principles that we all agree on:

• I/O is expensive.

• Function call overhead is a factor so we should inline short, frequently called functions.

• Copying objects is expensive. Prefer pass-by-reference over pass-by-value.

Our initial

Trace implementation has adhered to all three of these principles. We avoided I/O if tracing

was off, all methods were inlined, and all

string arguments were passed by reference. We stuck by the

rules and yet we got blindsided. Obviously, the collective wisdom of the previous rules fell short of the

expertise required to develop high-performance C++.

Our experience suggests that the dominant issue in C++ performance is not covered by these three

principles. It is the creation (and eventual destruction) of unnecessary objects that were created in

anticipation of being used but are not. The

Trace implementation is an example of the devastating effect

of useless objects on performance, evident even in the simplest use of a

Trace object. The minimal usage

of a

Trace object is to log function entry and exit:

int myFunction(int x)

{

string name = "myFunction";

Trace t(name);

...

};

This minimal trace invokes a sequence of computations:

• Create the string name local to myFunction.

• Invoke the Trace constructor.

• The Trace constructor invokes the string constructor to create the member string.

剩余204页未读，继续阅读

xiaonengaijita

粉丝: 0
资源: 7

C++性能优化技术指南

Effective C++ 3个版本清晰pdf

Efficient C++

Efficient C++ 英文 CHM 非扫描版

用c++复现论文Secure Cloud Auditing with Efficient Ownership Transfer

c# cefsharp设置代理

STM32CubeIDE

YOLO7 C++ 下载

C++ epoll select poll

nodewebassembly

最新资源