http://blog.chinaunix.net/uid-25872711-id-3015683.html
Efficient C++ 第三章
虚函数
看如下例子:
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。
虚函数似乎有以下的几方面开销:
1) 必须在构造函数内初始化vptr
2) 虚函数是通过指针间接调用,必须先得到指向虚函数表的指针,然后访问正确的函数偏移量
3) 内联是编译时的选择,由于虚函数的类型判断发生在运行时,所以编译器不能内联虚函数。
公平的来讲,前两项并不算做性能损失。因为即使不使用虚函数,也需要付出类别的开销。初始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. }
其实,虚函数真正的损失只有第三条,无法内联函数是虚函数最大的性能损失。
由于函数内联造成的性能损失没有固定的代价,如果是简短、调用频繁的函数那么性能损失就比较明显。可以用模板来解决这一问题。
模板和继承
看如下线程锁的示例代码,要实现不同线程锁类型CriticalSection和Mutex的线程安全string类:
class Locker { public: Locker() {} virtual ~Locker() {} virtual void lock() = 0; virtual void unlock() = 0; };
按以下三种方法设计:
1)硬编码:从string类派生CirticalSectionString和MutexString,每个类包含特定的锁
2)虚函数:从string派生一个ThreadSafeString,包含Locker锁基类指针,通过虚函数加锁,开锁。
3)模板:创建一个Locker参数的模板字符串类
硬编码方式:
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可以内联,这样就没有不必要开销。
要点:
1)因为虚函数不能内联,这对调用频繁、简单的函数的性能开销影响较大。
2)如果设计可行,可以用模板,取代虚函数实现多态,减小性能损失。