向上转换函数指针是否安全？

Question

我有基类Object 和Event

class Object
{
//...
};

class Event
{
};

还有一个函数指针的类型定义

typedef void (Object::*PF) (Event*);

还有一个存储两个指针的无关类

class Dispatcher
{
public:
    Dispatcher (Object* obj, PF pf) : _obj (obj), _pf (pf)

    void call (Event* event)
    {
        _obj->*pf (event);
    }

    Object* _obj;
    PF _pf;
};

然后我有一个具体的对象和一个具体的事件

class ConcreteEvent : public Event
{
};

class ConcreteObject : public Object
{
public:
   void handle (ConcreteEvent* event)
   {
      // Do something specific for ConcreteEvent
   }
};

然后这样称呼它

ConcreteObject* obj = new ConcreteObject();
Dispatcher dispatcher (obj, static_cast<PF>(&ConcreteObject::handle));

ConcreteEvent* event = new ConcreteEvent ();
dispatcher.call (event);

我保证调度器总是会被正确的事件调用，即当它封装的函数指针实际上采用SomeOtherConcreteEvent时，我不会调用调度器并传递它ConcreteEvent

问题是：这能保证有效吗？在 linux 和 mingw 上的 gcc 4.7 中肯定可以正常工作。

Answer 1

来自 C++11 标准，第 4.11.2 节：

“指向类型为 cv T 的 B 的成员的指针”类型的纯右值，其中 B 是类类型，可以转换为 类型“指向 cv T 的 D 成员的指针”类型的纯右值，其中 D 是 B 的派生类（第 10 条）。如果 B 是 D 的不可访问（第 11 条）、模棱两可（10.2）或虚拟（10.1）基类，或虚拟的基类 D 的基类，需要这种转换的程序格式错误。转换的结果是指 在转换发生之前指向与指向成员的指针相同的成员，但它指的是基 类成员，就好像它是派生类的成员一样。

所以是的，这应该是安全的。

编辑：因此，如果您实际上是指 向下转换：，根据 C++11 5.2.9.12，这也是合法的：

类型为“指向 cv1 T 的成员的指针”类型的纯右值可以转换为类型为“指向的指针”的纯右值 类型 cv2 T 的 B”的成员，其中 B 是 D 的基类（第 10 条），如果从 “指向T类型B成员的指针”到“指向T类型D成员的指针”存在（4.11），与cv2相同 cv 限定为或大于 cv1。 69

Answer 2

我认为它是不安全的，有两个原因。

首先是指向成员函数的指针只能安全地向下传播（因为Derived 类必然继承了基类的函数，而反之则不然）。

class Base {
public:
   void foo();
}; // class Base

class Derived: public Base {
public:
   void bar();
};

using PBase = void (Base::*)();
using PDerived = void (Derived::*)();

int main() {
   PBase pb = &Base::foo;
   PDerived pd = &Derived::bar;

   pb = pd; // error: cannot convert 'PDerived {aka void (Derived::*)()}'
            //                    to 'PBase {aka void (Base::*)()}' in assignment
   pd = pb;
}

（如here所见）

第二个是你不能像那样改变参数的类型。为了说明这个问题，使用ConcreteObject: public virtual Object，你会发现它并没有像你希望的那样工作。

---

现在，这并不意味着你想做的事情是不可能的，只是它需要多一点。

理想情况下，您只需修复签名以同时获取Object 和Event，而不是使用成员函数，然后在必要时让它处理手动转换：

using Function = std::function<void(Object*,Event*)>;

void handle(Object* o, Event* e) {
    ConcreteObject* co = dynamic_cast<ConcreteObject*>(o);
    ConcreteEvent* ce = dynamic_cast<ConcreteEvent*>(e);

    if (co and ce) { co->handle(ce); }
}

或者任何你觉得舒服的施法/检查。

注意：使用 std::function 是为了与 lambdas/functors 兼容。