C++ 返回基类对象中的派生对象指针

我有以下问题，我不知道为什么这不起作用。编译器不会产生任何错误，但当我执行代码时，它会崩溃

我有一个基类Message和一个派生类MessageA

class Message{

protected:

Message(){}

public:

virtual ~Message(){}

virtual void setType(int type) = 0;
virtual int  getType() = 0;

protected:

int type;

};

class MessageA : public Message

{
public:
MessageA(const uint32_t cid);
MessageA();

~CanMessage();


void setCID(const uint32_t cid);


void setType(int type);
int  getType();


uint32_t getCID();

private:

uint32_t cid;

};

为了灵活起见，我选择了参数类型message*message作为函数receive的参数提供哪种消息

bool ReceiveSingle(Message* message)
{

message = new MessageA(0x53);

return true;

}

在另一个函数中调用该函数，其中应对返回的指针执行操作：

Message* temp_message; //Global variable

/*

....

*/

ReceiveSingle(temp_message)
{

    MessageA* temp = static_cast<MessageA*>(temp_message);

    int cid = temp->getCID();  // This operation does not work !!!!!       

}

消息*temp_消息//全局变量
/*
....
*/
接收单个（临时消息）
{
MessageA*temp=static\u cast（临时消息）；
int-cid=temp->getCID（）；//此操作不起作用！！！！！
}

因此，我希望保持

ReceiveSingle

的参数灵活，并选择基类类型Message*。函数本身创建一个派生对象指针，并应通过全局基本对象指针

temp\u消息*

返回该指针。以后应该可以访问派生对象的变量。静态强制转换可以工作，但是当我执行

getCID（）

te程序时崩溃。我找不到任何解决此错误的方法

如果有人能帮助我，那就太好了

---

非常感谢

根据您分配给临时消息的内容，它可能只是一条消息，而不是一条消息。

---

使用动态_转换而不是静态_转换，然后检查temp是否为NULL ptr/NULL。如果为空，则temp_message是一条消息，而不是MessageA。

考虑到您将静态地强制转换指针，您不会真正利用动态多态性

class Message{

protected:

Message(){}

public:

virtual ~Message(){}

virtual void setType(int type) = 0;
virtual int  getType() = 0;

protected:

int type;

};

class MessageA : public Message

{
public:
MessageA(const uint32_t cid);
MessageA();

~CanMessage();


void setCID(const uint32_t cid);


void setType(int type);
int  getType();


uint32_t getCID();

private:

uint32_t cid;

};

我的建议是使用静态多态性：

template<class Type>
auto func(const Type& t) {
    int cid = t.getCID();
    // ...
}   

---

最初的问题是：

bool ReceiveSingle(Message* message) {
    message = new MessageA(0x53);
    return true;
}

不是真的在修改传递的指针。快速修复：

bool ReceiveSingle(Message*& message) {
//                         ^
    message = new MessageA(0x53);
    return true;
}

---

但这是一个糟糕的想法，主要是因为您使用的是裸指针。

我找到了一个快速有效的解决方案：

ReceiveSingle(Message** message) {

    MessageA* new_message = new MessageA(0x53);

    *message = new_message;

    return true;

}

为了调用

ReceiveSingle（Message**Message）

和

Message*temp_Message

使用

ReceiveSingle(&temp_message);

然后，要访问存储在temp_message中的MessageA对象，请使用静态强制转换：

MessageA* tempA = static_cast<MessageA*>(temp_message);  

MessageA*tempA=static\u cast（临时消息）；

我不确定您的

ReceiveSingle

函数的语法是否正确。您没有返回类型，也没有为temp_消息指定类型（这将覆盖全局temp_消息变量）。。。根据编译器的不同，它们可能分别默认为void和int。@Majenko提示：这是一个函数调用。是吗？对我来说，这不像是一个函数调用。火车在哪里。。。？为什么后面有{和}？为什么它与全局变量定义在同一个范围内？@Majenko我很确定它的本意（考虑到上面的声明）。

{

和

}

用于声明嵌套的作用域块。很抱歉，{和}是错误的，在接收到single（temp_消息）后应该是一个；我将始终为temp_消息指定一个派生对象。因此，从不使用Message，而是始终使用MessageA或MessageB等等。因此Message是函数

ReceiveSingle（Message*Message）

的参数？提供

ReceiveSingle（）

的类实现了一个接口，以便为不同的派生消息类型提供

ReceiveSingle（）

的不同实现。实际上调用

ReceiveSingle（）

的方法不需要知道处理的是哪种类型的派生消息。因此，调用

ReceiveSingle（）

的函数应该通过参数向函数提供消息*对象<代码>接收单（）应该创建一个派生消息并将其存储在提供的参数

message*

中。调用函数应该能够向外部提供此

message

对象，外部只知道

message*

对象中包含哪个派生类型。我希望这有助于理解我试图实现的目标；）