0

我正在尝试编写一个消息处理程序，其基类是

1-处理程序基类

2-处理程序工厂，为正确的消息类型生成正确的处理程序

3-和消息的基本通用类

他们的代码是这样的：

#include <map>
#include<iostream>
//Base Handler
template<class MSG>
class Handler
{
    MSG message;
public:
    Handler(MSG message):message(message){
    }

    virtual void handle() = 0;
    MSG getMessage()
    {
        return message;
    }
};

//Base Handler Factory
template<class MSG>
class HandlerFactory {
public:
    virtual Handler<MSG> * create(MSG & message) = 0;
};

//Base message
template<class T>
class Message
{
    T messageType;
public:
    T getMessageType()
    {
        return messageType;
    }

    void setMessageType(T messageType_)
    {
        messageType = messageType_;
    }
};

//然后，根据消息类型，我为每个基类编写子类：

//my custom types
enum MessageType
{
    ANNOUNCE,
    KEY_SEND,
    KEY_REQUEST
};

//my first custom message format
class MyMessage_1 : public Message<MessageType>
{
    //...
};

//my first custom handler
class MyMessageHandler_1 : public Handler<MyMessage_1>
{

public:
    MyMessageHandler_1(MyMessage_1 &message_): Handler<MyMessage_1>(message_)
    {
    }
    void handle(){}
};

//my custom handler factory
class MyHandlerFactory : public HandlerFactory<Message<MessageType> > {
    Handler<Message<MessageType> > *value;
public:
    MyHandlerFactory(){};
    Handler<Message<MessageType>  > * create(Message<MessageType> & message){
        switch (message.getMessageType())
        {
        case ANNOUNCE:
            MyMessage_1 t1;
            value = new MyMessageHandler_1(t1);//error here
            break;
            //etc. etc.
        default:
            value = 0;
            break;
        };
        return value;
    };

};

//让我们放一个main，这样你就可以很容易地编译它

int main()
{

}

问题是，在 switch-case 子句中，我尝试为我的自定义消息类之一创建处理程序的实例时，出现以下错误：

templateArgList.cpp: In member function ‘virtual Handler<Message<MessageType> >* MyHandlerFactory::create(Message<MessageType>&)’:
templateArgList.cpp:86:37: error: cannot convert ‘MyMessageHandler_1*’ to ‘Handler<Message<MessageType> >*’ in assignment

我的印象是： Handler<Message<MessageType> > * 可以这样转换：

MyMessageHandler_1-> Handler<MyMessage_1>
                             ^
                             |
                     `Message<MessageType>`  which finally gives me:
                                                `Handler<Message<MessageType>  >`  :P

我错了吗？我当然是，为什么我会收到上述错误:)）我只是不知道为什么以及如何解决它。因此，如果您能帮助我，我将不胜感激。

非常感谢您的帮助

4

1 回答 1

1

这是一个非常简单的程序，与您所做的类似，但没有嵌套模板，因此可以理解：

#include <vector>

class A {
};

class B : public A {
};

int main() {

   std::vector<A>* va;
   va = new std::vector<B>;

}

事实上，g++ 给出了错误：

error: cannot convert ‘std::vector<B>*’ to ‘std::vector<A>*’ in assignment

这应该很清楚——A 的向量与 B 的向量不同，即使 B 继承自 A。为了能够利用继承，您必须拥有指向相关对象的指针。例如：

int main() {
   std::vector<A*> va(3);
   for (int i=0; i<3; ++i) {
      va[i] = new B;
   }
}

这里的类比是：

std::vector< > ----> Handler< >
A              ----> Message<MessageType>
B              ----> MyMessage_1

顺便说一句，您是否意识到您message在 MyMessageHandler_1 和 Handler<> 中都定义了一个名为的变量？这将导致 MyMessageHandler_1::message 隐藏 Handler<>::message。我不确定这是否是你想要的。

另外..您可能想查看Python 的 Twisted 包，因为它可能非常适合您正在构建的应用程序。（如果你不介意使用 Python。）

问题：“有什么改变我的代码的建议吗？”

回复：

好吧，我会尝试删除模板并享受继承的力量。Handler 类可以接受一个Message对象（或引用或指针），因为它们都是基类。的HandlerFactorycreate 也将接受一个Message对象。然后，您可以继续使用Message具有enum MessageType类型成员变量的类并在内部使用 switchHandlerFactor来确定Handler要创建的正确派生类。

NewHandler()或者代替枚举，您可以通过向 中添加一个“ ”函数来进一步利用继承Message，该函数将是纯虚拟的Message，并将在派生类中定义。这样，您就不需要开关——每种类型的消息都知道Handler它需要什么，并且因子只需调用message->NewHandler().

...确定您是否需要使用模板有点困难，因为我不确定您的项目将走向何方。然而，作为一个粗略的经验法则，当 (a) 你想为不同类型使用等效的代码块并且 (b) 你不能使用继承来完成它时，使用模板是一个好主意。Thestd::vector<>是一个很好的例子—— std::vector<int>and的行为std::vector<float>是相同的，但是int's 和float's 没有任何公共基础相关，因此不是重写 VectorI 和 VectorF 的代码，而是要求编译器重写代码反而。

到目前为止，您似乎可以利用继承来做您想做的事。它还有一个额外的好处，就是让其他人更容易阅读你的代码。:)

于 2013-05-08T04:13:29.467 回答