基于RAII的Log-Listener资源管理类设计方案咨询与优化建议

我们需要将LogListener对象附加到一个外部不可修改的中央管理Host类上，核心需求是：监听任务完成后必须立即从主机分离。希望通过自定义类的析构函数自动调用Host的detach方法，目前列出了三种候选方案，我倾向于第一种（使用最便捷），但它违反单一职责原则，且Listener派生类无法复用连接管理逻辑，想请教哪种方案更合适，也欢迎其他思路。

基础代码定义 #

#include <iostream>
#include <memory>
#include <set>
#include <utility>

// 监听器接口基类
// ================================================
class Listener {
public:
    virtual void listen(const std::string& msg) = 0;
};

// 中央管理主机（外部代码，不可修改）
// ==============================================================
class Host {
public:
    void attach(Listener* listener) { m_coll.insert(listener); };
    void detach(Listener* listener) { m_coll.erase(listener); };
    void call(const std::string& msg) { 
        for(auto* L : m_coll) { 
            L->listen(msg); 
        }
    }
private:
    std::set<Listener*> m_coll;
};

static Host globalHost{};

// 示例派生监听器
class DerivedListener : public Listener {
public:
    void listen (const std::string& msg) override { 
        std::cout << "Two!\n"; 
    }
};

三种候选方案分析 #

方案1：ManagerA（监听器+管理二合一） #

// 方案1：违反单一职责，但无生命周期问题
// 管理类与监听器合并为一个类
// ========================================================================
class ManagerA : public Listener {
public:
    ManagerA() { globalHost.attach(this); }
    ~ManagerA() { globalHost.detach(this); }
    void listen (const std::string& msg) override { std::cout << "One!\n"; }
};

• 优点：使用简单，无生命周期不一致问题
• 缺点：违反单一职责原则，同时承担监听业务和主机连接管理；后续Listener派生类无法复用连接管理逻辑

方案2：ManagerB（裸指针管理） #

// 方案2：存在生命周期问题
// 接收监听器裸指针，但如果监听器在Manager之前销毁，会导致野指针问题
// 此外无法处理空指针（Host不允许空指针）
// ==========================================================================
class ManagerB {
public:
    explicit ManagerB (Listener* listener) : m_ptr{listener} { 
        if (m_ptr) globalHost.attach(m_ptr); 
    }
    ~ManagerB() { globalHost.detach(m_ptr); }
private:
    Listener* m_ptr;
};

• 优点：分离了管理逻辑和监听业务
• 缺点：严重的生命周期风险（监听器对象可能先于ManagerB销毁，导致detach时访问野指针）；无法处理空指针输入

方案3：ManagerC（独占所有权管理） #

// 方案3：接管监听器所有权，无生命周期问题
// 但需要实现claim方法让调用者取回所有权，调用后Manager内部资源为空
// ==========================================================================
class ManagerC {
public:
    explicit ManagerC (std::unique_ptr<Listener> listener) : m_ptr{std::move(listener)}
        { if (m_ptr) globalHost.attach(m_ptr.get()); }
    ~ManagerC() { globalHost.detach(m_ptr.get()); }
    std::unique_ptr<Listener> claim() { 
        globalHost.detach(m_ptr.get()); 
        return std::exchange(m_ptr, nullptr); 
    }
private:
    std::unique_ptr<Listener> m_ptr;
};

• 优点：无生命周期问题，分离了管理与监听逻辑
• 缺点：使用复杂，必须通过claim方法转移监听器所有权；claim后ManagerC内部资源为空，需要额外处理空状态

推荐方案与扩展思路 #

优先推荐：独立连接管理类（方案4） #

单独实现一个专注于连接管理的类，让Listener只负责业务逻辑，完全遵循单一职责：

class ListenerAttacher {
public:
    explicit ListenerAttacher(Listener* listener, Host& host = globalHost)
        : m_listener(listener), m_host(host) {
        if (m_listener) {
            m_host.attach(m_listener);
        }
    }

    ~ListenerAttacher() {
        if (m_listener) {
            m_host.detach(m_listener);
        }
    }

    // 禁止拷贝，允许移动避免重复attach/detach
    ListenerAttacher(const ListenerAttacher&) = delete;
    ListenerAttacher& operator=(const ListenerAttacher&) = delete;
    ListenerAttacher(ListenerAttacher&& other) noexcept
        : m_listener(other.m_listener), m_host(other.m_host) {
        other.m_listener = nullptr;
    }
    ListenerAttacher& operator=(ListenerAttacher&& other) noexcept {
        if (this != &other) {
            // 先 detach 当前监听器
            if (m_listener) {
                m_host.detach(m_listener);
            }
            m_listener = other.m_listener;
            m_host = other.m_host;
            other.m_listener = nullptr;
        }
        return *this;
    }

private:
    Listener* m_listener = nullptr;
    Host& m_host;
};

• 优点：完全遵循单一职责，连接管理逻辑可复用；通过移动语义避免重复操作，使用时只需绑定Attacher与Listener的生命周期即可
• 使用示例：

int main() {
    DerivedListener listener;
    ListenerAttacher attacher(&listener); // 构造时自动attach
    // 监听任务结束，attacher析构时自动detach
    return 0;
}

其他思路：自定义智能指针包装器 #

如果需要更灵活的所有权管理，可以实现一个封装了attach/detach逻辑的智能指针：

template<typename T>
class ListenerPtr {
public:
    explicit ListenerPtr(std::unique_ptr<T> ptr, Host& host = globalHost)
        : m_ptr(std::move(ptr)), m_host(host) {
        if (m_ptr) {
            m_host.attach(m_ptr.get());
        }
    }

    ~ListenerPtr() {
        if (m_ptr) {
            m_host.detach(m_ptr.get());
        }
    }

    // 提供标准智能指针操作接口
    T* get() const { return m_ptr.get(); }
    T& operator*() const { return *m_ptr; }
    T* operator->() const { return m_ptr.get(); }

    // 禁止拷贝，允许移动
    ListenerPtr(const ListenerPtr&) = delete;
    ListenerPtr& operator=(const ListenerPtr&) = delete;
    ListenerPtr(ListenerPtr&&) noexcept = default;
    ListenerPtr& operator=(ListenerPtr&&) noexcept = default;

private:
    std::unique_ptr<T> m_ptr;
    Host& m_host;
};

• 使用示例：

int main() {
    ListenerPtr<DerivedListener> listenerPtr(std::make_unique<DerivedListener>());
    // listenerPtr销毁时自动detach
    return 0;
}

内容的提问来源于stack exchange，提问作者Markus Moll