模拟虚函数？

最新推荐文章于 2025-06-19 00:06:01 发布

原创最新推荐文章于 2025-06-19 00:06:01 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#fun #class #设计模式 #string #iterator #编译器

本文围绕模板模拟虚函数展开，介绍书中通过模板实现仿真动态绑定的方法，经分析发现这并非真正模拟虚函数，只是在特定情景下类似，不支持虚函数重要性质。它是一种程序设计idiom，有特定用途、原理和使用方法，也存在虚拟性质无传递性等缺陷。

模拟虚函数？

近几天看《ATL INTERNALS》，看到了附录中的一个关于template的小技巧－仿真动态绑定：

template 
class Array {
public:
……
 virtual int Compare(const Array& rhs) =0;
 
 bool operator< (const Array& rhs)
 { return this->Compare(rhs) < 0; }
 
 bool operator> (const Array& rhs)
 { return this->Compare(rhs) >0; }
 bool operator== (const Array& rhs)
 { return this->Compare(rhs) == 0; }
 T m_rg[1024];
};

然后派生类重写这个虚函数获得多态特性：

class String : public Array {
public:
 int Compare(const Array& rhs)
 { return strcmp(m_rg, rhs.m_rg); }
};

为了实现虚函数需要一个vptr和一个vtable，以及需要至少经过两次提领操作才能调用正确的函数。

然后书中介绍了一种提供效率的办法：

template <typename T, typename Deriving>
class Array {
public:
……
 bool operator< (const Array& rhs)
 { return static_cast(this)->Compare(rhs) < 0; }
 
 bool operator> (const Array& rhs)
 { return static_cast(this)->Compare(rhs) > 0; }
 
 bool operator== (const Array& rhs)
 { return static_cast(this)->Compare(rhs) == 0; }
 T m_rg[1024];
};

注意Array模板接受一个附加的参数——派生类的名字。它利用这个类名完成堆自己的静态强制转换。因为编译器会在实例化（具象化）派生类的同时展开基类的代码，所以静态强制转换完成了一个完全安全的向下转换。

class String : public Array<char, String> {
public:
 int Compare(const Array& rhs)
 { return strcmp(m_rg, rhs.m_rg); }
};

这项技术在不使用虚成员的情况下使得我们看到并且感受到了动态绑定。真的有那么神奇吗？虚函数真的可用通过模板来模拟？当然不是

一开始的时候我还觉得迷惑，但是隐约觉得这个东西只是看上去像虚函数，但是限制多多。于是上网去问高手。gigix一开始被我说晕了，也怪我表述不好。问babysloth，一列出代码他就知道了这个是什么了。他说： “这叫curiously recurring template pattern，由bell-lab的james coplien首先记录下来”

紧接着，我偶然看到以前下载的ATL相关技术解析的文章，里面详细说了这个东西。文章是Codeguru上的《ATL Under the Hood Part 3》。简短的一个程序说明了这个东西：

#include 
using namespace std;
class Base {
public:
  virtual void fun() {
    cout << "Base::fun" << endl;
  }
  void doSomething() {
    fun();
  }
};
class Drive : public Base {
public:
  void fun() {
    cout << "Drive::fun" << endl;
  }
};
int main() {
  Drive obj;
  obj.doSomething();
  return 0;
}

这段程序中的行为和下面的这段程序是一样的：

#include 
using namespace std;
template 
class Base {
public:
  void fun() {
    cout << "Base::fun" << endl;
  }
  void doSomething() {
    T* pT = static_cast(this);
    pT->fun();
  }
};
class Drive : public Base {
public:
  void fun() {
    cout << "Drive::fun" << endl;
  }
};
int main() {
  Drive obj;
  obj.doSomething();
  return 0;
}

这里说的结果是一样的。引用虫虫的一句话：“效率不同”。

问题就是这里只是表现了虚函数的一个部分，虚函数一个经典的例子是用数组来保存派生类指针，通过指针调用被改写了的虚函数来表现多态。用这个模拟的版本可以这么作吗？不行！

下面这么作是不行的：

#include 
using namespace std;
template 
class Base {
public:
  void fun() {
    cout << "Base::fun" << endl;
  }
  void doSomething() {
    T* pT = static_cast(this);
    pT->fun();
  }
};
class Drive1 : public Base {
public:
  void fun() {
    cout << "Drive1::fun" << endl;
  }
};
class Drive2 : public Base {
public:
  void fun() {
    cout << "Drive2::fun" << endl;
  }
};
int main() {
  Base* pBase = NULL;
  pBase = new Drive1;
  pBase->doSomething();
  delete pBase;
  pBase = new Drive2;
  pBase->doSomething();
  return 0;
}

因为Drive2与Drive1不匹配。另外这么模拟虚函数只能维持一层，不能像真正的虚函数一样在派生的层次中任意的往下，虚函数一直都是虚函数。例如：

#include 
using namespace std;
template 
class Base {
public:
  void fun() {
    cout << "Base::fun" << endl;
  }
  void doSomething() {
    T* pT = static_cast(this);
    pT->fun();
  }
};
class Drive : public Base {
public:
  void fun() {
    cout << "Drive::fun" << endl;
  }
};
class MostDrive : public Drive {
public:
  void fun() {
    cout << "MostDrive::fun" << endl;
  }
};
int main() {
  MostDrive obj;
  obj.doSomething();
  return 0;
}

输出是Drive::fun而不是MostDrive::fun