C++：绑定到基类

Question

编辑：

在以下代码中container::push采用从base派生的T类型的对象作为参数并将指向方法 bool T::test() 的指针存储在向量中。

container::call 在成员对象 p 的上下文中调用每个存储的方法，其类型为 base，而不是T。只要被调用的方法不引用 base 之外的任何成员，并且 test() 未声明为 virtual，它就可以工作。

我知道这很丑陋，甚至可能不正确。

我怎样才能以更好的方式完成同样的事情？

#include <iostream>
#include <tr1/functional>
#include <vector>

class base {
   public:
   base(int v) : x(v)
   {}
   bool test() const { // this is NOT called
      return false;
   }

   protected:
   int x;
};

class derived : public base {
   public:
   bool test() const { // this is called instead
      return (x == 42);
   }
};

class container {
   public:
   container() : p(42)
   {}
   template<typename T>
   void push(const T&) {
      vec.push_back((bool (base::*)() const) &T::test);
   }
   void call() {
      std::vector<bool (base::*)() const>::iterator i;
      for(i = vec.begin(); i != vec.end(); ++i) {
         if( (p .* (*i))() ) {
            std::cout << "ok\n";
         }
      }
   }

   private:
   std::vector<bool (base::*)() const> vec;
   base p;
};

int main(int argc, char* argv[]) {
   container c;
   c.push(derived());
   c.call();
   return 0;
}

Answer 1

您对“boost::bind”语句所做的事情是调用衍生::test 并将“b”作为“this”指针传递。重要的是要记住，derivative::test 的“this”指针应该是指向“派生”对象的指针 - 但您的情况并非如此。它适用于您的特定情况，因为您没有 vtable 并且内存布局是相同的 - 但一旦这种情况发生变化，您的程序可能会崩溃。

此外，这完全是错误的——丑陋、不可读、容易出错的代码。你到底想做什么？

[编辑]已编辑问题的新答案：您应该使用 boost::bind 创建一个功能闭包，它包装了对象和对象。单个对象中的成员函数 - 并将该对象存储在您的集合中。那么当你调用它时，它总是可靠的。
如果你不能在你的应用程序中使用 boost...那么，你可以自己做一些类似 boost::bind 的事情（只需看看它在 boost 中是如何完成的），但更有可能的是你会出错并出现错误。

Answer 2

对于更新的问题：

在基础对象上调用派生成员函数是未定义的行为。您试图实现的目标（代码）是错误的。尝试发布您需要的内容，人们会帮助您进行合理的设计。

Answer 3

您所做的事情是不正确的，在简单的示例中它会起作用，但在其他情况下可能只会引发地狱（未定义行为的可能性之一）。

由于 base::test 和 衍生::test 不是虚拟的，它们是两个不同的成员方法，因此为了简单起见，我将它们称为 base::foo< /code> 和 衍生::bar。在绑定器代码中，您强制编译器调整在 衍生 中定义的指向 bar 的指针，就好像它实际上是在 base 中定义的一样，并且然后调用它。也就是说，您正在调用对象或类型base 上的派生 方法！！！这是未定义的行为。

它没有消亡的原因是 base 和 衍生 中的 this 指针重合，并且您仅访问 base 中存在的数据>基类。但这是不正确的。

当您将 base::test 声明为 virtual 时，您会得到正确的行为：层次结构中最派生的对象是 base，编译器将使用虚拟调度机制并找出base 是找到并执行 test 的最终重写器的地方。

当您仅将衍生::test声明为虚拟（而不是基）时，编译器将尝试在传递的对象中使用不存在的虚拟调度机制（通常是虚函数表指针）这会杀死应用程序。

无论如何，除了虚拟 base::test 之外的所有使用都是不正确的。根据您的实际要求，最可能正确的方法是：

class base {
public:
   virtual bool test() const;
};
class derived : public base {
public:
   virtual bool test() const; // <--- virtual is optional here, but informative
};
int main()
{
   derived d; // <--- the actual final type
   base & b = d;  // <--- optional
   if ( std::tr1::bind( &base::test, std::tr1::ref(b))() ) {
      // ...
   }
}

请注意，没有强制转换（强制转换通常是对一些奇怪的东西的暗示，潜在的危险隐藏在那里），该对象是具体类型您希望在哪里调用该方法，并且虚拟调度机制保证即使
bind 是base::test，由于该方法是虚拟的，因此将执行最终的重写器。

这个另一个例子更有可能做有趣的事情（我还没有尝试过）：

struct base {
   void foo() {}
};
struct derived : base {
   void foo() { 
      for ( int i = 0; i < 1000; ++i ) {
         std::cout << data[i];
      }
   }
   int data[1000];
};
int main() {
   base b;
   std::tr1::bind((void (base::*)()) &derived::foo, std::tr1::ref(b))();
}