C++ 请求-响应系统

我有带有相应响应对象的请求对象。发送方对象发出请求，然后侦听响应。一个发送器/侦听器对象可以发送不同的请求。每个请求都进入一个全局队列，处理后，相应的响应会发送到每个侦听器对象。

有几种解决方案。一种是，收发机通知所有

请求

对象其破坏情况。为此，您需要一种类似

收发器：：addRequest（）

对象使用它来注册自身。在

收发器的析构函数

您必须通知所有注册的

请求

。例如：

class Transceiver
{
    virtual ~Transceiver()
    {
        for (auto request : m_requests)
            request->deleteTransceiver(this);
    }

    void addRequest(Request* r)
    {
        m_requests.push_back(r);
    }

    void removeRequest(Request* r)
    {
        m_requests.erase(std::remove(m_requests.begin(), m_requests.end(), r), 
                         m_requests.end());
    }

    std::vector<Request*> m_requests;
};

class Request
{
    virtual void deleteTransceiver(Transceiver* t) = 0;
    virtual void notify() = 0;
};

class RequestImpl : public Request
{
    RequestImpl(Transceiver* t)
        : m_target(t)
    {
        if (t)
            t->addRequest(this);
    }

    ~RequestImpl()
    {
        if (m_target)
            m_target->removeRequest(this);
    }

    virtual void deleteTransceiver(Transceiver* t)
    {
        if (m_target == t)
            m_target = 0;
    }

    virtual void notify() 
    { 
        if (m_target)
            m_target->process(ResponseType()); 
    }

    Transceiver* m_target;
};

类收发器
{
虚拟收发器（）
{
用于（自动请求：m_请求）
请求->删除收发器（此）；
}
无效添加请求（请求*r）
{
m_请求。推回（r）；
}
清除无效请求（请求*r）
{
m_requests.erase（std:：remove（m_requests.begin（），m_requests.end（），r），
m_requests.end（））；
}
std：：向量m_请求；
};
类请求
{
虚拟收发器（收发器*t）=0；
虚拟void notify（）=0；
};
类RequestImpl：公共请求
{
RequestImpl（收发器*t）
：m_目标（t）
{
if（t）
t->addRequest（这个）；
}
~RequestImpl（）
{
如果（m_目标）
m_target->removeRequest（此）；
}
虚拟收发器（收发器*t）
{
如果（m_目标==t）
m_目标=0；
}
虚拟void notify（）
{ 
如果（m_目标）
m_target->process（ResponseType（））；
}
收发器*m_目标；
};

第二种方法当然是防止破坏

收发器
as
只要它还在使用。您可以在中使用
std:：shared_ptr m_target
请求
类，这意味着收发器的寿命至少与相关请求的寿命相同

为了更灵活一点，还可以使用
std:：weak_ptr
。然后，当请求发出时，收发器可能会被破坏
他还活着。但是，当您尝试使用
std:：weak\u ptr:：lock（）
时
失败，您知道
收发器
已关闭

编辑：添加了一种方法，如果请求在其
收发器
之前被销毁，则可以删除该请求
可能是共享指针还是弱指针？