Question

I have request objects with corresponding response objects. Sender object makes a request and then listens for response. One sender/listener object may send different requests. Every request goes into a global queue and after it was processed, corresponding response is sent to every listener object.

Answer 1

There are several solutions to your problem. One would be, that the transceiver informs all Request object about its destruction. For this, you would need a method like
Transceiver::addRequest() which a Request object uses to register itself. In the
destructor of Transceiver you have to inform all registered Request‘s. For example:

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;
};

A second approach would of course be to prevent the destruction of a Transceiver as
long as it is in use. You could use a std::shared_ptr<Transceiver> m_target in the
Request class, which means the transceiver lives at least as long as the associated request.

For a bit more flexibility, there is also the possibility of an std::weak_ptr<Transceiver>. Then the transceiver could be destroyed when the request
is still alive. However, when you try a std::weak_ptr<Transceiver>::lock() and it
fails, you know that the Transceiver is dead.

Edit: Added a method to remove a Request if it is destroyed before its Transceiver.