3

我有一个Message与消息总线一起使用的结构，我想用消息发送数据。问题是数据的类型会有所不同；也许对于一条消息，我只想发送一个 int，但对于另一条消息，我想发送几个 int、一个字符串，甚至可能是一个指向对象的指针。我可以做这样的事情：

struct Message {
    std::map<int, int> intPayload;
    std::map<int, std::string> strPayload;
    short id;
};

但这不仅丑陋且不干净，而且可能会浪费空间，而且如果我想传递一个相对奇特的数据类型，例如指向类实例的指针，这并不能解释。我应该为此使用什么？

4

3 回答 3

2

一个使用继承和多态的简单示例：

struct MessageBase
{
    // The function to send *this* message to the receiver
    virtual void send(ReceiverClass*) = 0;
};

struct MessageInt : MessageBase
{
    int payload;

    void send(ReceiverClass* receiver)
    {
        // Code to send this message type to the receiver...
    }
};

struct MessageString : MessageBase
{
    std::string payload;

    void send(ReceiverClass* receiver)
    {
        // Code to send this message type to the receiver...
    }
};

// ...

// Vector to store the messages
std::vector<MessageBase*> messages;

// Add a couple of messages
messages.push_back(new MessageInt{123});
messages.push_back(new MessageString{"Foobar"});

// Send the message to some receiver
for (auto const* message : messages)
    message->send(some_reciver_object);

任何一本好书都应该能给你更多的信息。

于 2017-01-15T06:52:30.580 回答
2

您可以将您的解决方案基于访问者模式。
作为一个最小的工作示例：

struct Listener;

struct Message {
    virtual void accept(Listener &) = 0;
};

struct SimpleMessage: Message {
    void accept(Listener &) override;
    int i;
};

struct ComplexMessage: Message {
    void accept(Listener &) override;
    int i;
    char c;
    double d;
};

struct Listener {
    void visit(SimpleMessage &) {}
    void visit(ComplexMessage &) {}
    void listen(Message &m) { m.accept(*this); }
};

void SimpleMessage::accept(Listener &l) { l.visit(*this); }
void ComplexMessage::accept(Listener &l) { l.visit(*this); }

struct Bus {
    Bus(Listener *l): l{l} {}
    void publish(Message &m) { l->listen(m); }
private:
    Listener *l;
};

int main() {
    Listener l;
    Bus b{&l};

    SimpleMessage sm;
    ComplexMessage cm;

    b.publish(sm);
    b.publish(cm);
}

撇开 的实现Bus是微不足道的事实不谈，请注意visit成员函数 inListener可以是虚拟的。
这样，您的所有侦听器都可以从该类派生并覆盖所需的方法。
将Bus接受一组Listeners，无论实际派生类型是什么，以及一个泛型Message。另一方面，消息将自己提升为正确的派生类型并将引用传递给给定的侦听器。

如果您想进一步探索，访问者模式背后的技术也称为双重调度。

于 2017-01-15T07:02:38.317 回答
1

有很多方法可以做到这一点。以下是 C++17 的示例std::variant：

std::vector<std::variant<int, std::string>> vec1;

vec1.emplace_back(1);
vec1.emplace_back("hello"s);

doSomethingWithInt( std::get<int>(vec1[0]) );
doSomethingWithString( std::get<std::string>(vec1[1]) );

vec1是一个元素列表，要么是int要么std::string。

您还可以使用静态访问者：

std::vector<std::variant<int, std::string>> vec2;

// ...

for(auto&& variant : vec1) {
    variant.visit([](auto value){
        using t = decltype(value);

        if constexpr (std::is_same_v<t, int>) {
            std::cout << "value is a int!" << std::endl;
        } else if constexpr (std::is_same_v<t, std::string>) {
            std::cout << "value is a string!" << std::endl;
        }
    });
}
于 2017-01-15T07:05:34.773 回答