Efficient C++ 第三章

转自
[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]