Question

各位大家好！

我的问题如下：

我有一个模板类，它存储指向其他类方法的指针（当然模板类最初并不知道要传递给它的类的类型）。我创建了模板类的构造函数，以获取指向传入的类的指针，以及另一个参数，它是我要存储的传入类的方法的地址，如下所示：

    template <typename MyClass>
    TemplateClass
    {
    typedef void (MyClass::*MethodPointer)();
    MyClass* theClass;
    MethodPointer methodPointer;
public:
    TemplateClass(MyClass* cl, MethodPointer func) : theClass(cl), methodPointer(func){}

    void Excute()
    {
        return (theClass->*methodPointer)();
    }
    };

然后，我创建了一个基类，并从中派生了一个子类。

    class BaseClass
    {
        // other details are omitted...
        virtual void DoSomething();
    };

    class DerivedClass : public BaseClass
    {
        // other details are omitted...
        void DoSomething();
    };

    // the definitions of the methods is omitted because it had no relevance to the issue

然后，我创建了一个模板类的typedef，将基类作为参数，例如：

    typedef TemplateClass<BaseClass> TypedTemplateClass;

然后，当我尝试将派生类的指针传递给TypedTemplateClass的构造函数时，编译器说它不能将派生类中的参数转换为基类，如下所示：

    DerivedClass* myDerivedObject = new DerivedClass();
    TypedTemplateClass* myTemplateObject = new TypedTemplateClass(myDerivedObject, &DerivedClass::DoSomething);

但是如果我传递基类本身的对象，一切都运行良好！如下：

    BaseClass* baseObject = new BaseClass();
    TypedTemplateClass* myTemplateObject2 = new TypedTemplateClass(baseObject, &BaseClass::DoSomething);

那么，有人可以启发我解决这个问题吗？我知道问题在于类型化模板类需要一个基类对象，但我需要传递派生类对象 - 因为我打算创建不同的派生类，并能够将它们的方法多态地传递给模板类。我也知道我可以忽略TypedTemplateClass定义，只创建每个具有不同派生类类型的模板类对象。但是，上述提议是我的意图。

我正在使用visual studio IDE

提前感谢您的关心和帮助。

Answer 1

问题是你不能将指向方法的指针转换为指向派生方法的类型指针指向基本类型的方法，因为指向方法的指针是逆变与对象类型。

考虑：

Base instance;
void (Base::*pmethod)();
pmethod = &Base::doSomething;
(instance.*pmethod)();    // OK

如果你被允许写

pmethod = &Derived::doSomethingElse;

然后您可以使用pmethod在类型为Derived::doSomethingElse的{{1}}上调用instance。

在Liskov's substitution principle下，派生对象（引用）是一个Base对象（引用），因为您可以对Base执行任何操作，但是指向方法的指针派生的不是指向基础方法的指针;实际上，它是另一种方式（指向Base的方法是指向Derived的方法），这就是为什么我们说指针到方法是逆变的：

Base

在你的情况下，最好的选择可能是编写一个模板化的构造函数并使用类型擦除来隐藏Derived方法指针的类型;在以下

void (Derived::*pmethod)() = &Base::doSomething;

构造函数类型中的两个template<typename T> TemplateClass(T *instance, void (T::*pmethod)());可以相互抵消，以提供函数签名T。您可以使用void ()成员执行此操作：

std::function<void ()>

Answer 2

这是什么意思：TemplateClass(MyClass* class, &MyClass::SomeMethod);它不是有效的C ++代码。你为什么不坚持使用c ++标准库？如果需要存储可调用对象，请使用由lambda构造的std::function。编译器和库将负责所有必要的转换...

Answer 3

嗯，我所处理的项目是一个试验，用于建立一种机制来处理类似C ++的事件 - 或多或少是C＃方式的事件和事件处理程序。因此，经过在线研究和一些文本研究并找出合适的方法，我写了两个模板类：一种是存储成员方法的指针，并将其命名为“EventHandler”。另一个是存储事件处理程序的映射并在需要时调用它们;这是'赛事'课程。然后我写了两个“普通”类：一个是事件触发类，另一个是响应或监听类。 Event和EventHandler类的初始版本如下：

#include <functional>

namespace eventhandling
{
#ifndef __BASIC_EVENT_HANDLER__
#define __BASIC_EVENT_HANDLER__

////////////////////////////////////////////////////////////////////////////
// the root event handler class
////////////////////////////////////////////////////////////////////////////
template <typename empty = int, empty = 0>
class BaseEventHandler
{
public:
    virtual void Excute() = 0;
};


///////////////////////////////////////////////////////////////////////////
// the basic derived event handler class; the class which will wrap the
// methods of other classes which want to respond to specific event(s)..
///////////////////////////////////////////////////////////////////////////
template <typename ResponderType>
class EventHandler : public BaseEventHandler < >
{
    typedef void (ResponderType::*MethodPointer());

    ResponderType* responder;
    MethodPointer methodPointer;

public:
    EventHandler(ResponderType* resp, MethodPointer func) : responder(resp), methodPointer(func)
    {}

    void Excute()
    {
        return methodPointer();
    }
};

#endif
}

#include "BasicEventHandler.h"
#include <map>

namespace eventhandling
{
#ifndef __BASIC_EVENT__
#define __BASIC_EVENT__

////////////////////////////////////////////////////////////////////////////////////////////////
// the event class which will receive these event handlers, stores them in a map object,
// and call them squentially when invoked from within the event firing method...
////////////////////////////////////////////////////////////////////////////////////////////////

// the template takes no parameters, so I added an empty parameter, just because
//it cannot ignore the parameter list, otherwise it will be considered template specialization
template <typename empty = int, empty = 0>
class BasicEvent
{
    //store the eventhandlers in a map so that I can track them from outside the class by id
    typedef std::map<int, BaseEventHandler<empty>* > Responders;
    Responders responders;
    int respondersCount;

public:
    BasicEvent() : respondersCount(0)
    {}

    // classical add method templatized so that it accepts any object
    template <typename Responder>
    int Add(Responder* sender, void (Responder::*memberFunc)())
    {
        responders[respondersCount] = (new EventHandler<Responder>(sender, memberFunc));
        respondersCount++;
        return respondersCount - 1;
    }

    // simple method to clean up the map memory after done with the eventhandlers
    void Remove(int responderID)
    {
        Responders::iterator it = responders.find(responderID);
        if (it == responders.end())
            return;
        delete it->second;
        responders.erase(it);
    }

    // method which invokes all the eventhandlers alltogether without control from the outside
    void Invoke()
    {
        Responders::iterator it = responders.begin();
        for (; it != responders.end(); ++it)
        {
            it->second->Excute();
        }
    }

    // method which invokes only the eventhandler whose id has been passed to it
    void Invoke(int id)
    {
        Responders::iterator it = responders.find(id);
        if (it != responders.end())
            it->second->Excute();
    }

    // overloaded operator+= to replace the functionality of method Add()
    template <typename Responder>
    void operator+=(EventHandler<Responder>* eventhandler)
    {
        responders[respondersCount] = eventhandler;
        respondersCount++;
    }

    // overloaded operator -= to replace the functionality of method Remove()
    void operator-=(int id)
    {
        Responders::iterator it = responders.find(id);
        if (it == responders.end())
            return;
        delete it->second;
        responders.erase(it);
    }

    //simple method which gives the size of the map object
    int Size()
    {
        return respondersCount;
    }
};
#endif
}

然后，我想在创建一个新的EventHandler对象时摆脱明确的'＆lt; ... ..＆gt;'模板语法，这显然是C＃中的情况，因此，我简单地做了如下：

    typedef EventHandler<MyClass> SomeEventFired_EventHandler;

所以当我需要创建这个模板的新对象时，我只需要写：

    MyClass* myObject = new MyClass();
    MyEventFiringClass* firingObject = new MyEventFiringClass();
    firingObject->OnFired += new SomeEventFired_EventHandler(myObject, &MyClass::SomeMethod);

当然，稍后的完整代码示例将使其更加清晰！这是我的问题，我希望能够传递MyClass派生类的对象。问题是如上所示的EventHandler模板不接受这样的派生对象，因为它只是期望基类的对象，并且编译器抱怨它无法从派生类转换为基类。这里有ecatmur的宝贵帮助，当他向我展示了使TempHandler类的构造函数模板化的正确方法。这样，当我使用MyClass作为基类键入定义的SomeEventFired_EventHandler时，只要该对象来自从MyClass派生的类，我就能够将任何对象及其方法传递给它的构造函数。这是我实现EventHandler多态特性的最终目标。我想要这个功能，因为如果你检查C＃中的EventHandlers，你可以看到System :: EventHandler是多态的，它接受来自类的不同对象，这些类本质上是从类Object派生出来的。所以，这是一个完整的例子，基于ecatmur解决方案的纠正的EventHandler类，供你们查看，我希望你会发现它有一些好处。最终，您可以从BaseEventHandler类派生，以便派生的EventHandlers可以存储具有不同返回类型和不同参数参数的方法，因为此处显示的基本方法接受返回void并取消void的方法（我相信您可以通过更改std :: function＆lt;＆gt;的声明，使其接受其他类型的方法，例如

std::function<int(int)>

，等等。）

事件类与上面相同......

#include <functional>

namespace eventhandling
{
#ifndef __BASIC_EVENT_HANDLER__
#define __BASIC_EVENT_HANDLER__

////////////////////////////////////////////////////////////////////////////
// the root event handler class
////////////////////////////////////////////////////////////////////////////
template <typename empty = int, empty = 0>
class BaseEventHandler
{
public:
    virtual void Excute() = 0;
};


///////////////////////////////////////////////////////////////////////////
// the basic derived event handler class; the class which will wrap the
// methods of other classes which want to respond to specific event(s)..
///////////////////////////////////////////////////////////////////////////
template <typename ResponderType>
class EventHandler : public BaseEventHandler < >
{
    std::function<void ()> type_erased_method;
    ResponderType* responder;

public:

    template<typename T>
    EventHandler(T* resp, void (T::*MethodPointer)()) : responder(resp), type_erased_method(std::bind(MethodPointer, resp))
    {}

    void Excute()
    {
        return type_erased_method();
    }
};

#endif
}

事件触发类头文件...

#include <iostream>
#include <string>
#include "BasicEvent.h"

namespace eventhandling
{
#ifndef __FONT_SIMULATOR__
#define __FONT_SIMULATOR__

typedef BasicEvent<> FontEvent;
typedef std::string s;

class FontSimulator
{

private:
    s fontName;
    s fontSize;
    s fontStyle;
public:
    FontSimulator();
    FontSimulator(s name, s size, s style);
    ~FontSimulator();

    FontEvent OnDraw;

    void DrawText();

    // the setting methods
    void SetFontName(s n) {fontName = n;}
    void SetFontSize(s si) {fontSize = si;}
    void SetFontStyle(s st) {fontStyle = st;}

    // the getting methods
    s GetFontName() {return fontName;}
    s GetFontSize() {return fontSize;}
    s GetFontStyle() {return fontStyle;}
};
#endif
}

其源文件.cpp

#include "FontSimulator.h"

using namespace eventhandling;

FontSimulator::FontSimulator() : fontName("Default Name"), fontSize ("Default Size"), fontStyle("Default Style")
{
}

FontSimulator::FontSimulator(s fName, s fSize, s fStyle) : fontName(fName), fontSize(fSize), fontStyle(fStyle)
{
}

FontSimulator::~FontSimulator()
{
delete this;
}

void FontSimulator::DrawText()
{
std::cout << "Initialization of font done!" << std::endl << std::endl;
std::cout << fontName << std::endl;
std::cout << fontSize << std::endl;
std::cout << fontStyle << std::endl << std::endl;

for (int i = 0; i < OnDraw.Size(); ++i)
{
    OnDraw.Invoke(i);
    std::cout << "the #" << i + 1 << " responder method called!" << std::endl << std::endl;
    std::cout << fontName << std::endl;
    std::cout << fontSize << std::endl;
    std::cout << fontStyle << std::endl << std::endl;
}
for (int j = 0; j < OnDraw.Size(); j++)
{
    //OnDraw.Remove(j);
    OnDraw -= j;
}

        std::cout << "The finishing font work after all the event handler are called!" << std::endl <<std::endl;
   }

处理字体类事件的抽象基类......

#include "BasicEventHandler.h"

namespace eventhandling
{
#ifndef __IFONT_CLIENT__
#define __IFONT_CLIENT__

class IFontClient
{
public:
    IFontClient(){};
    ~IFontClient(){delete this;}
    virtual void SetupFont() = 0;
};

typedef EventHandler<IFontClient> FontEventHandler;

#endif
}

来自IFontClient ...头文件的派生类首先

#include "BasicEventHandler.h"
#include "BasicEvent.h"
#include "FontSimulator.h"
#include "IFontClient.h"

namespace eventhandling
{
#ifndef __CONTROL_SIMULATOR__
#define __CONTROL_SIMULATOR__

class ControlSimulator : public IFontClient
{
protected:
    std::string caption;
    FontSimulator* font;

public:
    ControlSimulator();
    ControlSimulator(std::string theCaption, FontSimulator* theFont);
    ~ControlSimulator();

    virtual void Draw();
    virtual void SetupFont();

    void SetCaption(std::string c) {caption = c;}
    std::string GetCaption() {return caption;}
};

#endif
}

其源文件.cpp

#include "ControlSimulator.h"

namespace eventhandling
{
ControlSimulator::ControlSimulator() : caption("Default Caption"), font(new FontSimulator())
{
}

ControlSimulator::ControlSimulator(std::string c, FontSimulator* f) : caption(c), font(f)
{
}

ControlSimulator::~ControlSimulator()
{
    delete this;
}

void ControlSimulator::Draw()
{
    std::cout << "Drawing " << caption << " is done!" << std::endl << std::endl;
}

void ControlSimulator::SetupFont()
{
    std::string costumProperty = caption;
    font->SetFontName(costumProperty.append(", Costumized Font Name"));

    costumProperty = caption;
    font->SetFontSize(costumProperty.append(", Costumized Font Size"));

    costumProperty = caption;
    font->SetFontStyle(costumProperty.append(", Costumized Font Style"));
}
}

测试应用的主要条目

#include "ControlSimulator.h"

using namespace eventhandling;

int main(int argc, char** argv)
{
char c;

FontSimulator* font = new FontSimulator();
ControlSimulator* control1 = new ControlSimulator("Control one", font);
ControlSimulator* control2 = new ControlSimulator("Control two", font);

control1->Draw();
control2->Draw();

font->OnDraw += new FontEventHandler(control1, &ControlSimulator::SetupFont);
font->OnDraw += new FontEventHandler(control2, &ControlSimulator::SetupFont);

font->DrawText();

std::cout << "Enter any character to exit!" << std::endl;
std::cin >> c;

return 0;
}

将派生类对象传递给模板类的构造函数

3 个答案: