std::tr1::function::target<TFuncPtr> 和协/逆变答案

【问题标题】：std::tr1::function::target<TFuncPtr> and co-/contravariancestd::tr1::function::target<TFuncPtr> 和协/逆变
【发布时间】：2010-07-12 11:11:46
【问题描述】：

由于我喜欢使用 C# 和 C++ 进行编程，因此我即将实现一个类似 C# 的事件系统，作为我计划中的 C++ SFML-GUI 的坚实基础。

这只是我的代码的摘录，我希望这能澄清我的概念：

// Event.h
// STL headers:
#include <functional>
#include <type_traits>
#include <iostream>
// boost headers:
#include <boost/signals/trackable.hpp>
#include <boost/signal.hpp>

namespace Utils
{
    namespace Gui
    {
        #define IMPLEMENTS_EVENT(EVENTNAME, EVENTARGS) public: \
            Utils::Gui::IEvent<EVENTARGS>& EVENTNAME() { return m_on##EVENTNAME; } \
        protected: \
            virtual void On##EVENTNAME(EVENTARGS& e) { m_on##EVENTNAME(this, e); } \
        private: \
            Utils::Gui::Event<EVENTARGS> m_on##EVENTNAME;


        #define MAKE_EVENTFIRING_CLASS(EVENTNAME, EVENTARGS) class Fires##EVENTNAME##Event \
        { \
            IMPLEMENTS_EVENT(EVENTNAME, EVENTARGS); \
        };


        class EventArgs
        {
        public:
            static EventArgs Empty;
        };

        EventArgs EventArgs::Empty = EventArgs();

        template<class TEventArgs>
        class EventHandler : public std::function<void (void*, TEventArgs&)>
        {
            static_assert(std::is_base_of<EventArgs, TEventArgs>::value, 
                "EventHandler must be instantiated with a TEventArgs template paramater type deriving from EventArgs.");
        public:
            typedef void Signature(void*, TEventArgs&);
            typedef void (*HandlerPtr)(void*, TEventArgs&);

            EventHandler() : std::function<Signature>() { }

            template<class TContravariantEventArgs>
            EventHandler(const EventHandler<TContravariantEventArgs>& rhs)
                : std::function<Signature>(reinterpret_cast<HandlerPtr>(*rhs.target<EventHandler<TContravariantEventArgs>::HandlerPtr>())) 
            {
                static_assert(std::is_base_of<TContravariantEventArgs, TEventArgs>::value,
                    "The eventHandler instance to copy does not suffice the rules of contravariance.");
            }

            template<class F>
            EventHandler(F f) : std::function<Signature>(f) { }

            template<class F, class Allocator>
            EventHandler(F f, Allocator alloc) : std::function<Signature>(f, alloc) { }
        };

        template<class TEventArgs>
        class IEvent
        {
        public:
            typedef boost::signal<void (void*, TEventArgs&)> SignalType;

            void operator+= (const EventHandler<TEventArgs>& eventHandler)
            {
                Subscribe(eventHandler);
            }

            void operator-= (const EventHandler<TEventArgs>& eventHandler)
            {
                Unsubscribe(eventHandler);
            }

            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler) = 0;

            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler, int group) = 0;

            virtual void Unsubscribe(const EventHandler<TEventArgs>& eventHandler) = 0;
        };

        template<class TEventArgs>
        class Event : public IEvent<TEventArgs>
        {
        public:
            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler)
            {
                m_signal.connect(*eventHandler.target<EventHandler<TEventArgs>::HandlerPtr>());
            }

            virtual void Subscribe(const EventHandler<TEventArgs>& eventHandler, int group)
            {
                m_signal.connect(group, *eventHandler.target<EventHandler<TEventArgs>::HandlerPtr>());
            }

            virtual void Unsubscribe(const EventHandler<TEventArgs>& eventHandler)
            {
                m_signal.disconnect(*eventHandler.target<EventHandler<TEventArgs>::HandlerPtr>());
            }

            void operator() (void* sender, TEventArgs& e)
            {
                m_signal(sender, e);
            }

        private:
            SignalType m_signal;
        };

        class IEventListener : public boost::signals::trackable
        {
        };
    };
};

如你所见，我使用 boost::signal 作为我的实际事件系统，但我用 IEvent 接口（它实际上是一个抽象类）对其进行了封装，以防止事件侦听器通过 operator() 触发事件.

为方便起见，我重载了加赋值和减赋值运算符。如果我现在从 IEventListener 派生我的事件监听类，我就可以编写代码而无需担心信号中的函数指针悬空。

到目前为止，我正在测试我的结果，但std::tr1::function::target<TFuncPtr>() 有问题：

class BaseEventArgs : public Utils::Gui::EventArgs
{
};

class DerivedEventArgs : public BaseEventArgs
{
};

void Event_BaseEventRaised(void* sender, BaseEventArgs& e)
{
    std::cout << "Event_BaseEventRaised called";
}

void Event_DerivedEventRaised(void* sender, DerivedEventArgs& e)
{
   std::cout << "Event_DerivedEventRaised called";
}

int main()
{
    using namespace Utils::Gui;
    typedef EventHandler<BaseEventArgs>::HandlerPtr pfnBaseEventHandler;
    typedef EventHandler<DerivedEventArgs>::HandlerPtr pfnNewEventHandler;

    // BaseEventHandler with a function taking a BaseEventArgs
    EventHandler<BaseEventArgs> baseEventHandler(Event_BaseEventRaised);
    // DerivedEventHandler with a function taking a DerivedEventArgs
    EventHandler<DerivedEventArgs> newEventHandler(Event_DerivedEventRaised);
    // DerivedEventHandler with a function taking a BaseEventArgs -> Covariance
    EventHandler<DerivedEventArgs> covariantBaseEventHandler(Event_BaseEventRaised);

    const pfnBaseEventHandler* pBaseFunc = baseEventHandler.target<pfnBaseEventHandler>();
    std::cout << "baseEventHandler function pointer is " << ((pBaseFunc != nullptr) ? "valid" : "invalid") << std::endl;

    const pfnNewEventHandler* pNewFunc = newEventHandler.target<pfnNewEventHandler>();
    std::cout << "baseEventHandler function pointer is " << ((pNewFunc != nullptr) ? "valid" : "invalid") << std::endl;

    // Here is the error, covariantBaseEventHandler actually stores a pfnBaseEventHandler:
    pNewFunc = covariantBaseEventHandler.target<pfnNewEventHandler>();
    std::cout << "covariantBaseEventHandler as pfnNewEventHandler function pointer is " << ((pNewFunc != nullptr) ? "valid" : "invalid") << std::endl;

    // This works as expected, but template forces compile-time knowledge of the function pointer type
    pBaseFunc = covariantBaseEventHandler.target<pfnBaseEventHandler>();
    std::cout << "covariantBaseEventHandler as pfnBaseEventHandler function pointer is " << ((pBaseFunc != nullptr) ? "valid" : "invalid") << std::endl;

    return EXIT_SUCCESS;
}

EventHandler<TEventArgs>::target<TFuncPtr>() 方法只会在 TFuncPtr 与 Functor 中存储的类型完全相同时返回有效指针，而不管协方差如何。由于 RTTI 检查，它禁止将指针作为标准的弱类型 C 函数指针访问，这在这种情况下有点烦人。

EventHandler 是 DerivedEventArgs 类型，但仍然指向 pfnBaseEventHandler 函数，即使该函数通过构造函数运行。

这意味着，std::tr1::function 本身“支持”逆变，但如果我不这样做，我找不到简单地从 std::tr1::funcion 对象中获取函数指针的方法在编译时知道它的类型，这是模板参数所必需的。

如果他们像 RAII 指针类型一样添加了一个简单的 get() 方法，我将不胜感激。

由于我对编程很陌生，我想知道是否有办法解决这个问题，最好是在编译时通过模板（我认为这是唯一的方法）。

【问题讨论】：

要格式化代码，选择然后点击文本输入区域上方的 1010 按钮 - 不要使用 HTML pre 和/或代码标签。
@Sebastion：您可以使用编辑窗口顶部的小101010 按钮来格式化代码。（并且您阅读了浮动在编辑窗口右侧的帮助以获取帮助。）我进入并格式化了您的代码。
是的，我阅读了有关缩进的内容并对其进行了测试，但是由于预览没有立即格式化代码，所以我使用了 HTML 标记。现在我肯定更聪明了。谢谢你们三个收拾我的东西。 @Roger Pate：是的，这就是我所怀疑的......我现在将尝试建立一个更短的示例。
好的，找到了（过渡？）解决方案：在模板化的 EventHandler 复制构造函数重载中，我错过了 reinterpret_cast。现在使用模板参数来访问 std::tr1::function 的强类型指针，然后将指针重新转换为与新 EventHandler 实例的 HandlerPtr 类型匹配的函数指针。（我希望能够更好地用英语表达自己，所以请原谅我的解释，也许看看我第一篇文章中的代码。）
第一名：Hör auf，Dich für Dein Englisch zu entschuldigen。 Es langt, wenn Du daran arbeitest, es zu verbessern。 Wobei ich bezweifle, daß Dein Deutsch weniger langatmig ist ;) 第二：这不是这里的工作方式：如果您找到了问题的解决方案，请自行回答您的问题。等待两天后，您可以接受它作为正确答案。

标签： c++ boost-signals boost-function

【解决方案1】：

刚刚找到问题的解决方案。看来我只是错过了另一个地点的演员表：

template<class TEventArgs>
class EventHandler : public std::function<void (void*, TEventArgs&)>
{
public:
    typedef void Signature(void*, TEventArgs&);
    typedef void (*HandlerPtr)(void*, TEventArgs&);

    // ...

    template<class TContravariantEventArgs>
    EventHandler(const EventHandler<TContravariantEventArgs>& rhs)
        : std::function<Signature>(reinterpret_cast<HandlerPtr>(*rhs.target<EventHandler<TContravariantEventArgs>::HandlerPtr>())) 
    {
        static_assert(std::is_base_of<TContravariantEventArgs, TEventArgs>::value,
            "The eventHandler instance to copy does not suffice the rules of contravariance.");
    }

    // ...
}

这可以正常工作。尽管如此，还是感谢您让我顺利进入这个非常棒的社区！

【讨论】：