我正在尝试从 Is it possible to write a template to check for a function's existence? 中汲取灵感并应用它们，但我遇到了一些麻烦。我有以下定义:

#define HAS_MEM_FUNC(func, name)                                        \
    template<typename T, typename Sign>                                 \
    struct name {\
        typedef char yes[1];                                            \
        typedef char no[2];                                            \
        template <typename U, U> struct type_check;                     \
        template <typename _1> static yes &chk(type_check<Sign, &_1::func> *); \
        template <typename   > static no  &chk(...);                    \
        static bool const value = sizeof(chk<T>(0)) == sizeof(yes);     \
    }

// Creates a member function detector and two overloads of a message handler
// registration function, one that registers a member function of a specific name
// if it exists and another that does nothing if that member function doesn't exist.

#define DEFINE_REGISTER_FUNC(msgid, msgtype, handlername) \
    HAS_MEM_FUNC(handlername, has_##handlername);\
    template <typename T>\
    static void register_##handlername(\
        T* pWnd, \
        typename std::enable_if<has_##handlername<T, void(T::*)(msgtype&)>::value, T>::type* t = nullptr) \
    {\
        (void) t;\
        pWnd->setMessageHandler(\
            msgid,\
            Handler<msgtype>(std::bind(&T::handlername, pWnd, std::placeholders::_1)));\
    }\
    \
    template <typename T> \
    static void register_##handlername(\
        T* pWnd, \
        typename std::enable_if<!has_##handlername<T, void(T::*)(msgtype&)>::value, T>::type* t = nullptr) \
    {\
        (void)pWnd;\
        (void)t;\
    }

我也有一个这样定义的类:

template <typename T>
class RegisterHandlers
{
public:
    template <typename T>
    static void registerHandlers(T* pWnd)
    {
        register_onCreate(pWnd);
        register_onPaint(pWnd);
    }

private:
    DEFINE_REGISTER_FUNC(WM_CREATE, CreateMessage, onCreate);
    DEFINE_REGISTER_FUNC(WM_PAINT, PaintMessage, onPaint);
};

这个想法是，如果类 T 有一个成员函数 onCreate(CreateMessage&)，它将自动注册为 WM_CREATE 的处理程序>。如果它没有这样的方法，那么将调用 register_onCreate 的无操作重载，编译器会很高兴。 onPaint 处理程序也是如此(我包括它主要是为了说明 SFINAE 确实工作)。

如果我有这样的类(class)，这会很好用:

class MainWnd
{
public:
    friend class RegisterHandlers<MainWnd>;

    MainWnd()
    {
        RegisterHandlers<MainWnd>::registerHandlers(this);
    }

protected:
    void onCreate(CreateMessage&) { /* do some stuff */ }
};

但是，当我添加这个时:

class SubWnd : public MainWnd
{
public:
    friend class RegisterHandlers<SubWnd>;

    SubWnd()
    {
        RegisterHandlers<SubWnd>::registerHandlers(this);
    }

protected:
    void onPaint(PaintMessage&) { /* do some stuff */ }
};

我收到一个错误，提示 MainWnd::onCreate 不可访问(无法访问 protected 成员)。我分解了宏以帮助找到问题实际发生的位置，它似乎在 HAS_MEM_FUNC 宏中，可能在这一行:

template <typename _1> static yes &chk(type_check<Sign, &_1::func> *);

所以，我真的有两个问题:

1. 是否可以在不公开事件处理程序的情况下完成我想做的事情？
2. 如果基类已经这样做，是否也可以避免重新注册事件处理程序？换句话说，有没有办法判断函数是在基类中声明的还是源自派生类？

如果相关，我正在尝试在 Visual Studio 2013 预览版编译器上执行此操作。这个问题的动机是我正在试验 C++11 功能和 Windows API 包装器，我试图看看是否有比大型 vtable 和消息映射宏更好的解决方案来将消息路由到适当的处理程序。

最佳答案

这里的障碍是:

类 SubWnd , 源自 MinWnd , 宣告友元:

friend class RegisterHandlers<SubWnd>;

所以RegisterHandlers<SubWnd>::registerHandlers(this)可以做它的注册 自己 protected 处理程序 onPaint并且 - 冗余 - 的 protected 处理程序 onCreate它继承自 MainWnd .这 后者注册是多余的，因为基地 类 MainWnd的构造函数已经注册了 onCreate . RegisterHandlers<T>::registerHandlers(WinType *)总是要“注册” 任何窗口可能拥有的所有处理程序，如果 WinType 则执行空操作 实际上没有给定的处理程序，如果有则重复注册 已经由基类构造函数完成。

但要注册onCreate ，冗余与否，这是一个 protected 成员 的 MainWnd , RegisterHandlers<SubWnd>需要成为MainWnd的 friend . 它不是:它只是 SubWnd 的 friend .

您无法摆脱 RegisterHandlers<T> 的模板参数化 按窗口类型 T因为您依赖于您的模板参数 SFINAE方法-内省(introspection)

但是这个SFINAE的方法——反省，不得不说， 在目前的情况下是徒劳的。您的每个窗口类构造函数 仍然需要做一些事情来注册自己的处理程序。你想要的方式 解决这个问题的方法是将任务委托(delegate)给 RegisterHandlers<T>::registerHandlers(WinType *) ，这将:

• 尝试注册任何窗口可能拥有的所有处理程序，
• 什么都不做 WinType没有处理程序，
• 在 WinType 时冗余地重新注册处理程序的基类构造函数已经注册了它，并且
• 非冗余且成功地注册了 WinType 的特定处理程序.

所有这一切中，每个窗口类型实际但不可避免地需要做的唯一部分是最后一部分。所以 对你的两个问题:

1. Is it possible to do what I am trying to do without making the event handlers public?

是的。只需让每个窗口类型注册自己的处理程序即可。

2. Is it also possible to avoid re-registering event handlers if the base class already did it?

是的。相同的答案。

我明白你只是在试验，但这个试验没有希望。

您将第三个问题附加到问题 2:

Is there a way to tell if the function was declared in the base class or if it originated in the derived class

是的。如果再咨询this answer , 然后也咨询my answer to the same question 在下面，您将看到第一个解决方案检测到一个成员函数 T::mf 什么时候mf在 T 中定义但不是当mf由 T 继承，而我的 解决方案检测 mf在任一情况下。因此，您可以对 T::mf 进行 SFINAE 探测经过 这两种方法都会知道 mf如果第一个方法没有被继承 检测到它，第二种方法可以。

关于c++ - 我可以检测成员函数是否存在并且可以被 C++ 中的 friend 访问吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17755860/