Efficient C++ 第三章

秒速五厘米 2022-04-11 05:46 270阅读 0赞

转自  
\[url\]http://blog.chinaunix.net/uid-25872711-id-3015683.html\[/url\]  
  
\[align=center\]\[b\]Efficient C++ 第三章 \[/b\]\[/align\]  
  
\[b\]虚函数\[/b\]  
　　看如下例子：

class ZooAnimal {
       
    public:
        ...
        virtual void draw();
        int resolveType() {return myType;}
    private:
        int myType;
        ...
    }

ZooAnimal为动物园所有动物的基类，myType标明类型，如果要画出所有动物，可用如下方式实现：

void drawAllAnimals (ZooAnimal *pz) // pointer to first animal in the
                                        // list
    {
       
        for (ZooAnimal *p=pz; p ;p = p->next) {
       
             switch (p->resolveType()) {
       
             case BEAR:
                  ( (Bear *) p)->draw();
                  break;
             case MONKEY:
                  ((Monkey *) p)->draw();
                  break;
             ... // Handle all other animals currently in the zoo.
             }
             }
    }

但是这样的代码维护比较烦琐，当新增动物，或者去除动物的时候你需要不断的修改switch语句。这里可以使用虚函数处理，利用其动态绑定。

void drawAllAnimals (ZooAnimal *pz) // pointer to first animal in the
                                        // list
    {
       
        for (ZooAnimal *p=pz; p ;p = p->next) {
       
             p->draw();
             }
    }

当类X中存在虚函数，那么编译器会为类X产生一个虚函数表，虚函数表拥有该类的所有虚函数的指针。每一个类有一个虚函数表，类的每个对象都有一个隐藏的指向该表的指针。隐藏是因为，只有编译器知道vptr在对象内部的偏移量。编译器在对象的构造函数中插入代码，以正确初始化vptr。  
　　虚函数似乎有以下的几方面开销：  
\[color=red\]1) 必须在构造函数内初始化vptr  
2) 虚函数是通过指针间接调用，必须先得到指向虚函数表的指针，然后访问正确的函数偏移量  
3) 内联是编译时的选择，由于虚函数的类型判断发生在运行时，所以编译器不能内联虚函数。\[/color\]  
　　公平的来讲，前两项并不算做性能损失。因为即使不使用虚函数，也需要付出类别的开销。初始vptr的开销等价于Bear中初始化类型的开销，如：

class Bear : public ZooAnimal {
       
        ...
        Bear (const char *name) : myName(name), myType(BEAR) {}
        ...
    };

第二条函数调用的开销，等价于switch逻辑和区分不同类型Bear::Draw()的开销：

switch (p->resolveType()) {
       
     case BEAR:
       ( (Bear *) p)->draw();
       break;
     case MONKEY:
       ((Monkey *) p)->draw();
       break;
     ... // Handle all other animals currently in the zoo.
     }

其实，虚函数真正的损失只有第三条，无法内联函数是虚函数最大的性能损失。  
　　由于函数内联造成的性能损失没有固定的代价，如果是简短、调用频繁的函数那么性能损失就比较明显。可以用模板来解决这一问题。  
  
\[b\]模板和继承\[/b\]  
　　看如下线程锁的示例代码，要实现不同线程锁类型CriticalSection和Mutex的线程安全string类：

class Locker {
       
    public:
        Locker() {}
        virtual ~Locker() {}
        virtual void lock() = 0;
        virtual void unlock() = 0;
    };

按以下三种方法设计：  
\[color=red\] 1）硬编码：从string类派生CirticalSectionString和MutexString，每个类包含特定的锁  
2）虚函数：从string派生一个ThreadSafeString，包含Locker锁基类指针，通过虚函数加锁，开锁。  
3）模板：创建一个Locker参数的模板字符串类\[/color\]  
硬编码方式：

class CriticalSectionString : public string {
       
    public:
        ...
        int length();
    private:
        CriticalSectionLock cs;
    };
    
    int CriticalSectionString::length()
    {
       
        cs.lock()
        int len = string::length();
        cs.unlock();
    
        return len;
    }

显然这种方式没有额外开销，不同锁机制实现不同的string类型，lock和unlock可以在编译时刻确定，进行内联。  
  
虚函数：

class ThreadSafeString : public string {
       
    public:
        ThreadSafeString (const char *s, Locker *lockPtr)
        : string(s), pLock(lockPtr) {}
        ...
        int length();
    private:
        Locker *pLock;
    };
    
    int ThreadSafeString::length() 
    {
       
     pLock->lock();
     int len = string::length();
     pLock->unlock();
     return len; 
    }
    
    //使用时，如下：
    {
       
        CriticalSectionLock cs;
        ThreadSafeString csString("Hello", &cs);
        ...
    }
    
    {
       
        MutexLock mtx;
        ThreadSafeString csString("Hello", &mtx);
        ...
    }

通过虚函数动态绑定正确类型lock和unlock，代码较简单，但是虚函数不能内联，有性能损失。  
  
模板：

template <class LOCKER>
    class ThreadSafeString : public string {
       
    public:
        ThreadSafeString(const char *s) : string(s) {}
        ...
        int length();
    
    private:
        LOCKER lock;
    };
    
    template <class LOCKER>
    inline
    int ThreadSafeString<LOCKER>::length()
    {
       
        lock.lock();
        int len = string::length();
        lock.unlock();
    
        return len;
    }
    
    {
       
        ThreadSafeString <CriticalSectionLock> csString = "hello";
        ...
    }
    
    {
       
        ThreadSafeString <MutexLock> mtxString = "hello";
        ...
    }

模板可以很好的实现多态，也可以在编译时刻确定类型，因此lock和unlock可以内联，这样就没有不必要开销。  
  
要点：  
\[color=red\]　　1）因为虚函数不能内联，这对调用频繁、简单的函数的性能开销影响较大。  
　　2）如果设计可行，可以用模板，取代虚函数实现多态，减小性能损失。\[/color\]