成员函数指针从派生类到基类的强制转换

我正在执行以下操作：

• 获取成员函数指针3 params from a 派生类.
• 将其转换为成员函数指针基类 with 0 params.
• 将其投射到基类 with 3个参数 back.
• 呼唤着它。

它工作得很好（到目前为止），但我应该保留它吗？

当前代码说明：

EventsWarehouse用于存储和调用事件：

#include <iostream>
#include <functional>
#include <unordered_map>

class EventsWarehouse
{
public:
    typedef std::tuple<AView*, void (AView::*)()>           box_t;
    typedef std::unordered_multimap<std::string, box_t>     boxes_t;

    void        storeEvent(std::string const &event, AView *v, void (AView::*callback)())
        {
            this->_events.insert(std::make_pair(event, std::make_tuple(v, callback)));
            return ;
        }

    template<typename... Args>
    bool        fireEvent(std::string const &event, Args... args)
        {
            auto                it = this->_events.find(event);
            AView               *v;
            void                (AView::*callback_)();
            void                (AView::*callback)(Args...);

            for (; it != this->_events.end(); it++)
            {
                v = std::get<0>(it->second);
                callback_ = std::get<1>(it->second);
                /*
                ** CAST #2
                ** <void (AView::*)()>
                **  to
                ** <void (AView::*)(std::string, int, double)>
                **  before call
                */
                callback = reinterpret_cast<void (AView::*)(Args...)>(callback_);
                (v->*callback)(args...);
            }
            return (true);
        }
private:
    boxes_t         _events;

};

查看上面类中存储的类：

class AView
{
protected:
    AView(){}
};

class DerivedView : public AView
{
public:
    void    fooCallback(std::string s, int i, double d)
        {
            std::cout << "DerivedView::fooCallback received " << s << ", " << i << ", " << d << std::endl;
            return ;
        }
};

Main:

int                         main(void)
    {
        DerivedView     dv;
        EventsWarehouse ewh;

        /*
        ** CAST #1
        ** <void (DerivedView::*)(std::string, int, double)>
        **  to
        ** <void (AView::*)()>
        **  for storing purpose
        */
        ewh.storeEvent("event 1", &dv, reinterpret_cast<void (AView::*)()>(&DerivedView::fooCallback));
        ewh.fireEvent("event 1", std::string("Hello World"), 42, 84.42);
        return (0);
    }

根据 C++11 规范草案 n4296，5.2.10 重新解释强制转换 [expr.reinterpret.cast] §10

如果 T1 和 T2 都是函数类型或都是对象类型，则“指向 T1 类型 X 成员的指针”类型的纯右值可以显式转换为不同类型“指向 T2 类型 Y 成员的指针”的纯右值。 72 null 成员指针值 (4.11) 转换为目标类型的 null 成员指针值。此转换的结果未指定，但以下情况除外：

— 将“指向成员函数的指针”类型的纯右值转换为不同的指向成员函数的指针 类型并返回其原始类型会产生指向成员值的原始指针。

— 将“指向 T1 类型 X 的数据成员的指针”类型的纯右值转换为“指向数据的指针”类型 T2 类型 Y 的成员”（其中 T2 的对齐要求不比 T1 严格） 并返回其原始类型，产生指向成员值的原始指针。 转换为指向不带参数的成员函数的指针并返回到具有正确参数的成员函数应该返回原始指针。

恕我直言，问题是fooCallback仅定义于DerivedView类，因此它是not类的成员函数AView.

这是正确的：

void (AView::*p)() = reinterpret_cast<void (AView::*)()>(&DerivedView::fooCallback);
void (DerivedView::*callback)(std::string, int, double) =
       reinterpret_cast<void (DerivedView::*)(std::string, int, double)>(p);
v->callback("Hello World"), 42, 84.42);

假如v is a AView *指向一个DerivedView

但是当你结束转换时void (DerivedView::*)(std::string, int, double) to a void (AView::*)(std::string, int, double)它们是不同的类型，因此未指定转换

它有效，因为非静态非虚拟成员函数的常见实现只是一个普通（非成员）函数，其隐藏参数为this。因此，指向成员的指针仅存储该函数的地址，并使用指向 a 的指针正确调用它DerivedView给出预期的结果。但不同的实现也可以存储实际类型并引发异常（或执行其他操作）。

TL/DR：当你以从void (DerivedView::*)(std::string, int, double) to void (AView::*)(std::string, int, double)您不会将指向成员的指针转换为其原始类型并调用未定义的行为。