尝试使用重载运算符创建新的事件处理程序>>迷失了自己试图找出所需的语法

编辑，澄清：*我希望能够使用重载运算符>>使用我自己的类 EventListener 设置事件处理程序，但我无法弄清楚它的语法*

问题是重载的>>=运算符与参数化的事件处理程序不匹配，我不知道如何正确声明它！！

或

如果我让它匹配，将通用 T 类型转换为体面的有用 eventHandler 对象所需的信息就消失了！！我需要一个混合语法来声明一个泛型类型 T 和一个第二个泛型类型作为它的参数。

并且使用 eventHandler 类的父级，函数器也是无用的，因为它没有参数化。

例：

链接>>新的事件处理程序(&App：：testFunction，app(; /*where app is an istance of App class and testFunction is a method of App. */

我有一个名为 eventHandler 的类，它属于这种形式eventHandler<class T>。现在，我想重载某个类的>>运算符，以允许我像这样使用它：

link >> new eventHandler(&App::testFunction, App);

其中 App 是另一个类，而 testFunction 显然是该类的方法。写成 abose 的行应该具有对链接类的>>=运算符的调用(方便地称为 Link (。

我将发布我的部分代码以使其更清晰：

class Link
{
public:
    eventListener* EventListener;
    Link()
    {
        this->EventListener = new eventListener();
    }   
    // PROBLEM
    // I am lost here, tried different syntaxes but with no success
    //template<template<class G> class T, class F> 
    template <class T>
    Link operator>>=(T& ev)
    { 
        cout << "something";
         // Here there is no way to declare the proper eventHandler
        eventHandler<?>* event = (eventHandler<?>)ev;
         // I need something like T<F> 
        event->eventName = 'onTest';
        this->eventListener->add(event);
        return *this; 
} 
};
template<class T, class F> 
T operator>>(T& lhs, F& rhs)
{ 
    return T(lhs)>>=rhs;
} 
class App
{
public:
    void testFunction(e evt)
    {
        cout << "it works!" << "n";
    }
};
int main()
{
    App* app = new App;
    Link* link = new link;
    Link link1;
    eventHandler<App>* ev = new eventHandler<App>(app, &App::testFunction);
    link1 >> ev;    
    // this line should echo "it works!"
    link1.EventListener->triggerEvent("onTest");
    // PART 2
    // HOW CAN I USE?
    // link >> ev; 
    // when link is a Link*
    return 0;
}

我的问题是关于如何从 Link 声明方法operator>>=，以便自动为我启用这种功能。

澄清：- 我希望能够使用 Link 类上的 >> 运算符将新的事件处理程序添加到 EventListener 类中，该运算符具有右操作数和实际的事件处理程序;

编辑 1：

我还有第二个问题：如何声明 >> 重载函数，以便使用指向 Link 类的指针调用我......这意味着如果我想将link与>>一起使用而不是link1，我该怎么办。

回答 PART2：我的猜测是我只需要取消引用指针即可使用运算符重载。

另一个编辑

这是一个代码版本，可能会更好地解释它。我的问题是编译器失败的地方，在匹配 Link 类>>=运算符时，如果正确解决，它可能会起作用，问题是我找不到如何匹配它并保持事件签名。

现在，我最好让代码自己说话：

#include <iostream>
#include <stdio.h>
#include "events/events.h"
using namespace std;
class Link
{
public:
    eventListener* EventListener;
public:
    Link()
    {
        this->EventListener = new eventListener();
    }   
    template<class T>
    Link operator>>=(const T& ev)
    { 
        ev->eventName = "onReceive";
        this->EventListener->add(ev);
        return *this; 
    }
};
template<class T, class F> 
T operator>>(T& lhs, const F& rhs)
{ 
    return T(lhs)<<=rhs;
} 
class App
{
public:
    void testReceive(e evt)
    {
        cout << "it works" << "n" << evt.value;
    }
};
class demo
{
public:
    Link* parent;
    void testit(char* msg)
    {
        parent->EventListener->triggerEvent("onReceive", this, msg);
    }
};
int main()
{
    App* app = new App;
    Link link;
    eventHandler<App>* ev = new eventHandler<App>(app, &App::testReceive);
    link >> ev; 
    demo d;
    d.parent = &link;
    // should output "it works!"
    d.testit("here");
    return 0;
}

我还将发布我的事件定义：

#ifndef EVENTS_H
#define EVENTS_H
#include <stdio.h>
#include <string.h>
#include "clist.h"
#include <string>
enum scope {global = 0, scoped};
struct e
{
    void* target;
    void* value;
};
class efunctor //abstract
{
public:
    std::string eventname;
    virtual void operator()(e evt)
    { }
    virtual void Call(e evt)
    { }
};
template <class T>
class eventHandler : public efunctor
{
private:
    T* scope;
    void (T::*eventMethod)(e);
public:
    std::string name;
    std::string eventname;
    eventHandler(std::string eventnam, T* objscope,  void(T::*func)(e)) 
    { 
        this->scope = objscope;
        this->eventMethod = func;
        this->eventname = eventnam;
    }
    eventHandler(T* objscope,  void(T::*func)(e)) 
    { 
        this->scope = objscope;
        this->eventMethod = func;
    }
    eventHandler(void(T::*func)(e)) 
    {
        this->eventMethod = func;
    }
    void operator()(e evt)
    {
        (scope->*eventMethod)(evt);
    }          
    void Call(e evt)
    { 
        (scope->*eventMethod)(evt);
    }
};
class eventListener
{
private:
    clist< clist<efunctor* > > methods;
public:
    template <class T>
    void add(T other)
    {
        other->name = ToString(this->methods[other->eventname].length());
        methods[other->eventname][methods[other->eventname].length()] = other;
    }
    template <class T>
    void remove(T other)
    {
        methods[other->eventname]->remove(other->name);
    }
    template <class F>
    void triggerEvent(std::string name, void* target, F result)
    {
        e evt;
        evt.target = target;
        evt.value = (char*)result;
        for(methods[name].iterateStart(); 
                    !methods[name].eoi(); 
                    methods[name].next())
        {
            (*(methods[name].getCurrentIteration()))(evt);
        }
    }
};
#endif