如何用shared_ptr避免悬空指针？防止类对象原始指针存入容器

这确实是个非常头疼的问题——你好不容易把类A的生命周期完全交给shared_ptr管理，就怕有人随手调用get()掏出裸指针塞进容器，等对象被自动释放后，容器里的悬空指针就是定时炸弹。针对你的场景，我整理了几个从编译时到运行时的解决方案，一步步堵上这个漏洞：

方案1：封装自定义智能指针，彻底屏蔽裸指针获取路径 #

这是最彻底的方案——直接不让外部代码有机会拿到A的裸指针。我们可以封装一个专属的智能指针类，只暴露必要的操作（比如operator->、operator*），显式删除get()和裸指针转换的接口：

#include <memory>
#include <string>
#include <map>

class A {
protected:
    struct this_is_private;
private:
    // 把析构也设为私有，确保只有自定义智能指针能管理销毁
    ~A() = default;
    friend class ASharedPtr;
public:
    explicit A(const this_is_private &) {}
    A(const this_is_private &, std::string, int) {}
    
    // 示例业务方法
    void do_something() { /* ... */ }

protected:
    struct this_is_private {
        explicit this_is_private(int) {}
    };
    A(const A &) = delete;
    const A &operator=(const A &) = delete;
};

class ASharedPtr {
private:
    std::shared_ptr<A> m_ptr;
public:
    // 实现智能指针核心操作，让外部能正常使用对象
    A* operator->() const { return m_ptr.get(); }
    A& operator*() const { return *m_ptr; }
    explicit operator bool() const { return static_cast<bool>(m_ptr); }
    
    // 显式禁止获取裸指针和转换操作
    A* get() = delete;
    operator A*() = delete;

    // 替代原有的create方法，统一创建入口
    template <typename... T>
    static ASharedPtr create(T &&...args) {
        return ASharedPtr(std::make_shared<A>(A::this_is_private{0}, std::forward<T>(args)...));
    }
private:
    // 私有构造，确保只能通过create方法创建
    explicit ASharedPtr(std::shared_ptr<A> ptr) : m_ptr(std::move(ptr)) {}
};

// 合法的容器：只能存自定义智能指针
std::map<ASharedPtr, int> m_ok;

// 下面的代码会直接编译失败，因为拿不到A*
// std::map<A*, int> m_error;
// A* obj_ptr = temp.get();

ASharedPtr foo() {
    ASharedPtr temp = ASharedPtr::create();
    m_ok.insert(std::pair<ASharedPtr, int>(temp, 10)); // 完全合法
    return temp;
}

这种方案的好处是编译时就直接阻止违规操作，从根源上消除了裸指针泄露的可能；缺点是需要额外封装智能指针的常用接口，增加了少量代码量。

方案2：用不完整类型限制裸指针的可用性 #

如果不想封装自定义指针，可以把A的具体实现隐藏在cpp文件中，对外只暴露前向声明：

// A.h
#pragma once
#include <memory>
#include <string>

class A;
using APtr = std::shared_ptr<A>;

template <typename... T>
APtr createA(T&&... args);

// A.cpp
#include "A.h"

class A {
protected:
    struct this_is_private;
public:
    explicit A(const this_is_private &) {}
    A(const this_is_private &, std::string, int) {}
    
    void do_something() { /* ... */ }

protected:
    struct this_is_private {
        explicit this_is_private(int) {}
    };
    A(const A &) = delete;
    const A &operator=(const A &) = delete;
};

template <typename... T>
APtr createA(T&&... args) {
    return std::make_shared<A>(A::this_is_private{0}, std::forward<T>(args)...);
}

这时外部代码虽然能通过APtr.get()拿到A*，但因为A是不完整类型，无法解引用、delete或调用任何成员函数——即使有人把A*塞进容器，也没法实际使用它，能大幅降低风险。缺点是无法完全阻止裸指针存入容器，只能限制其可用性。

方案3：靠团队规范+自定义容器别名约束 #

如果团队信任度较高，可以统一使用自定义的容器别名，强制大家只能存shared_ptr<A>：

template <typename T>
using SafeObjectMap = std::map<std::shared_ptr<T>, int>;

// 项目中统一用这个，禁止直接用std::map<A*, int>
SafeObjectMap<A> m_ok;

这种方案成本最低，但完全依赖团队规范，无法从编译器层面阻止违规操作，适合小团队或信任度高的场景。

方案4：运行时检查（兜底方案） #

如果前面的方案都无法落地，可以在类A中加入运行时跟踪，比如用std::set记录所有存活的对象指针，在析构时检查是否还有未移除的裸指针引用：

#include <set>

class A {
protected:
    struct this_is_private;
private:
    static std::set<A*> s_alive_objects;
    ~A() {
        s_alive_objects.erase(this);
        // 可以在这里加断言，检查是否还有外部引用（比如容器里的裸指针）
        // assert(s_alive_objects.find(this) == s_alive_objects.end());
    }
public:
    explicit A(const this_is_private &) {
        s_alive_objects.insert(this);
    }
    // ... 其他原有代码 ...
};

std::set<A*> A::s_alive_objects;

这种方案只能在运行时发现问题，无法提前阻止，但可以在调试阶段快速定位违规代码。

总结 #

最推荐的是方案1，它能在编译时就彻底杜绝裸指针泄露的风险；如果不想增加代码量，方案2是性价比很高的选择；方案3适合依赖团队规范的场景；方案4作为兜底的调试手段。

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