场景三：一个类向多个类发送消息

场景三：一个类向多个类发送消息

假设有 recv1、recv2、recv3、recv4、recv5 类，分别使用 recv1、recv2、recv3、recv4、recv5 实例化了 5 个对象（在 main 函数中实例化），另有 sender 类，要在 sender 对象中发送消息给这所有 recv 对象。

mgnotify 消息库

使用 mgnotify 消息库，只需要将发送消息类在 sender 中实例化并发送即可，主打的就是随时随地可以随心所欲的发送消息。

mmv 用例源码：example12

关键代码：

// 1. 定义消息
class carrier : public BaseMessage<carrier>
{
public:
    string name;
    // 测试耗时: 开始时间
    chpt start_time;
};

// 2. 定义消息接收类
class recv1 : public BaseHandle<carrier>
{
public:
    recv1() : _id(-1) {}
    ~recv1() {}
    void setId(int id) { _id = id; }
    virtual bool handle(const carrier* msg) override;
private:
    int _id;
};

class recv2 : public BaseHandle<carrier>
{
public:
    recv2() : _id(-1) {}
    ~recv2() {}
    void setId(int id) { _id = id; }
    virtual bool handle(const carrier* msg) override;
private:
    int _id;
};

class recv3 : public BaseHandle<carrier>
{
public:
    recv3() : _id(-1) {}
    ~recv3() {}
    void setId(int id) { _id = id; }
    virtual bool handle(const carrier* msg) override;
private:
    int _id;
};

class recv4 : public BaseHandle<carrier>
{
public:
    recv4() : _id(-1) {}
    ~recv4() {}
    void setId(int id) { _id = id; }
    virtual bool handle(const carrier* msg) override;
private:
    int _id;
};

class recv5 : public BaseHandle<carrier>
{
public:
    recv5() : _id(-1) {}
    ~recv5() {}
    void setId(int id) { _id = id; }
    virtual bool handle(const carrier* msg) override;
private:
    int _id;
};


// 3. 类消息处理
bool recv1::handle(const carrier* msg)
{
    auto end = high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - msg->start_time;
    cout << "recv1--> id: " << _id << " name: " << msg->name << ", 从开始发送消息到接收消息耗时： " << elapsed.count() << " ms." << endl;

    return true;
}

bool recv2::handle(const carrier* msg)
{
    auto end = high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - msg->start_time;
    cout << "recv2--> id: " << _id << " name: " << msg->name << ", 从开始发送消息到接收消息耗时： " << elapsed.count() << " ms." << endl;

    return true;
}

bool recv3::handle(const carrier* msg)
{
    auto end = high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - msg->start_time;
    cout << "recv3--> id: " << _id << " name: " << msg->name << ", 从开始发送消息到接收消息耗时： " << elapsed.count() << " ms." << endl;

    return true;
}

bool recv4::handle(const carrier* msg)
{
    auto end = high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - msg->start_time;
    cout << "recv4--> id: " << _id << " name: " << msg->name << ", 从开始发送消息到接收消息耗时： " << elapsed.count() << " ms." << endl;

    return true;
}

bool recv5::handle(const carrier* msg)
{
    auto end = high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - msg->start_time;
    cout << "recv5--> id: " << _id << " name: " << msg->name << ", 从开始发送消息到接收消息耗时： " << elapsed.count() << " ms." << endl;

    return true;
}


// 4. sender 类中发送消息
class sender
{
public:
    sender() {}
    ~sender() {}
    void send() {
        carrier m1;
        m1.start_time = high_resolution_clock::now();
        m1.name = "ljj";
        // 发送同步消息（如果是异步消息，可能消息还没有接收完整，进程已经结束）
        m1.send();
    }
};

// 5. 构建对象并发送消息
int main()
{
    // 使用基类容器保存，这样一个容器就可以了
    list<IHandle*> rs1;
    auto start = high_resolution_clock::now();
    int count = 5;
    cout << count << "个接收者构建中，请稍后...\n";
    for(int i = 0; i < count; i++) {
        recv1 *r1 = new recv1;
        recv1 *r1 = new recv1;
        recv2 *r2 = new recv2;
        recv3 *r3 = new recv3;
        recv4 *r4 = new recv4;
        recv5 *r5 = new recv5;
        r1->setId(i);
        r2->setId(i);
        r3->setId(i);
        r4->setId(i);
        r5->setId(i);
        rs1.push_back(r1);
        rs1.push_back(r2);
        rs1.push_back(r3);
        rs1.push_back(r4);
        rs1.push_back(r5);
    }
    auto end = high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - start;
    cout << "attach " << count << " 接收者耗时：" << elapsed.count() << " ms." << endl;

    start = high_resolution_clock::now();
    while (!rs1.empty()) {
        auto t = rs1.back();
        rs1.pop_back();
        delete t;
        t = nullptr;
    }
    end = high_resolution_clock::now();
    elapsed = end - start;
    cout << "detach " << count << " 接收者耗时：" << elapsed.count() << " ms." << endl;
    
    return 0;
}

总结

这个复杂度应该在一般的项目中都能出现，这个时候是不是把优势体现出来了呢？

• IHandle 可以作为所有消息接收者的基类，方便管理
• 只需要增加多个类接收消息，发送消息端不需要仍和改变