Efficient C++ 第一章

悠悠 2022-04-11 05:46 308阅读 0赞

转自  
\[url\]http://blog.chinaunix.net/uid-25872711-id-3013832.html\[/url\]  
  
\[align=center\]\[size=medium\]Efficient C++ 第一章 \[/size\]\[/align\]  
  
Charpter 1 The tracing war story  
　　很多时候，为了方便查找bug，会使用trace。比如用如下方式：

#ifdef TRACE
        Trace t("myFuction"); // Constructor takes a function name argument
        t.debug("Some information message");
    #endif

这样的方式不错，但是问题是：每次TRACE宏的开头都要重新编译代码。想到用如下方式避免这一问题：

void Trace::debug(string &msg)
    {
       
        if (traceIsActive) {
       
          // log message here
          }
    }

加入一个traceIsActive变量来控制log开关，因为写log开销最大，这样看上去也算可行。下面看，假设有如下调用：

t.debug("x = " + itoa(x)); // itoa() converts an int to ascii

即使，traceIsActive为false，上面的调用还是会产生如下开销：  
\[color=red\] 1) 创建一个临时string变量保存“x=”  
2) 调用itoa()函数  
3) 创建一个临时string变量保存itoa(x)返回的char\*指针  
4) 连接两个字符串，组成第三个临时string变量  
5) debug return后，销毁所有临时变量\[/color\]  
这样下来对程序原有执行是大有影响的，尤其是在程序常用接口中加入TRACE，那将严重影响执行效率。  
  
\[b\]最开始的实现\[/b\]  
　　我们实现的trace主要在函数调用开始，调用结束，和中间部分写log信息。

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);
        ...
    }; // Trace destructor logs exit event to an output stream

上面的trace实现，经过测试，程序加入trace前后，效率降低了20%之多！！！  
  
\[b\]问题在哪呢？\[/b\]  
工程师对C++执行会有不同的理解，但是如下是最基本可知的原则：  
\[color=red\] 1) I/0开销很大  
2) 经常调用，而且很简短的函数声明为inline  
3) 拷贝实例开销大，多传引用而不是实例\[/color\]  
　　而我们的代码都符合3条原则，问题在于创建了过多我们并未真正使用的实例，下面是Trace的最小用例，程序调用开始和结束时写log记录。

int myFunction(int x)
    {
       
        string name = "myFunction";
        Trace t(name);
        ...
    };

它包含了如下开销：  
\[color=red\] 1)创建string实例name保存“myFunction”  
2) 调用Trace的构造函数  
3）Trace的构造函数调用string的构造函数，来初始化string成员  
（函数调用结束时）  
4）析构string实例name  
5）调用Trace的析构函数  
6）Trace析构函数调用string的析构函数，销毁string成员\[/color\]  
　　实际上，当我们不要用Trace做log，上面这些实例都是完全无用的，这些开销白白浪费掉了。来做如下测试：

int addOne(int x) // Version 0
    {
       
        return x+1;
    }
    int main()
    {
       
        Trace::traceIsActive = false;//Turn tracing off
        //...
        GetSystemTime(&t1); // Start timing
    
        for(i =0; i < j; i++) {
       
           y = addOne(i);
           }
    
        GetSystemTime(&t2); // Stop timing
        // ...
    }

我们将函数修改为如下，对比前后执行时间：

int addOne(int x) // Version 1. Introducing a Trace object
    {
       
        string name = "addOne";
        Trace t(name);
    
        return x+1;
    }

\[b\]\[color=red\]执行结果显示，前后执行时间为55ms和3500ms，相差了超过60倍！！！！\[/color\]\[/b\]  
  
\[b\]The Recovery Plan\[/b\]  
　　修改1，把addOne中创建的string实例name换成Char\*，修改如下：

int addOne(int x) // Version 2. Forget the string object.
                          // Use a char pointer instead.
    {
       
        char *name = "addOne";
        Trace t(name);
    
        return x+1;
    }
    //做上面修改，同时Trace构造函数修改为：
    inline
    Trace::Trace(const char *name) : theFunctionName(name)// Version 2
    {
       
        if (traceIsActive){
       
            cout << "Enter function" << name << endl;
        }
    }

这样，我们去除了name string实例的创建和析构的开销，执行时间由3500ms降到2500ms。  
　　下一步，去除Trace中string成员变量的不必要开销，成员变量用string指针代替，使用指针的好处是调用构造时，不会自动调用成员的构造函数，只是初始化指针值。我们可以辨别Trace状态，再调用构造函数。

class Trace { //Version 3. Use a string pointer
    public:
        Trace (const char *name) : theFunctionName(0)
        {
       
        if (traceIsActive) { // Conditional creation
           cout << "Enter function" << name < endl;
           theFunctionName = new string(name);
           }
        }
    
        ...
    private:
    
        string *theFunctionName;
    };
    
    
    inline
    Trace::~Trace()
    {
       
        if (traceIsActive) {
       
           cout << "Exit function " << *theFunctionName << endl;
           delete theFunctionName;
           }
    
    }

通过这一步优化，Trace中string实例的不必要开销也消除了。执行时间降到了185ms。  
  
\[b\]Key Point\[/b\]  
\[color=red\]　　1）不要传实例，多用引用  
　　2）常用的简单函数声明为inline  
　　3）I/O开销大  
　　4）尽量减小可能不被使用成员的调用构造、析构函数\[/color\]