模拟虚函数？

最新推荐文章于 2024-08-31 10:21:19 发布

taowen2002

最新推荐文章于 2024-08-31 10:21:19 发布

阅读量1k

点赞数

文章标签： fun class 设计模式 string iterator 编译器

本文链接：https://blog.youkuaiyun.com/taowen2002/article/details/15864

版权

模拟虚函数？

近几天看《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