Question

我正在尝试编写一个基类为

的消息处理程序

1-Handler基类

2-Handler Factory，为正确的消息类型生成适当的处理程序

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

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

非常感谢您的帮助

Answer 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

顺便提一下，您是否意识到在MyMessageHandler_1和Handler＆lt;＆gt;中都定义了名为message的变量？这将导致MyMessageHandler_1 :: message隐藏Handler＆lt;＆gt; :: message。我不确定这是不是你想要的。

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

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

响应：

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

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

...确定是否需要使用模板有点困难，因为我不确定你的项目在哪里。但是，作为一个粗略的经验法则，当（a）您想要使用不同类型的等效代码块并且（b）您不能使用继承来完成它时，最好使用模板。 std::vector<>就是一个很好的例子 - std::vector<int>和std::vector<float>的行为相同，但int和float的行为无关通过任何公共基础，所以不要重写VectorI和VectorF的代码，而是要求编译器重写代码。

到目前为止，看起来您可以利用继承来做您想做的事情。它还有一个额外的好处，即让其他人更容易阅读您的代码。：）

无法在嵌套的模板化类型之间进行转换

1 个答案: