c++ - 无法在嵌套模板类型之间转换

Question

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

1-处理程序基类

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 的 vector 与 B 的 vector 不同，即使 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。我不确定这是否是您想要的。

另外..你可能想看看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的与任何公共(public)基础无关，因此不是重写 VectorI 和 VectorF 的代码，而是要求编译器重写代码。

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