C++/CLI：多托管对象包装同一非托管对象的解决方案问询

你遇到的这个问题是C++/CLI混合开发里的经典坑——同一个非托管实例被多个托管包装器持有，最终导致重复析构崩溃。下面我给你分享几个经过项目验证的解决方案，你可以根据自己的场景选最合适的：

1. 给非托管对象添加引用计数（最通用的方案） #

核心思路是让非托管对象自己管理生命周期，只有当所有托管包装器都释放后，才真正销毁非托管实例。

修改非托管类： #

class UnmanagedB {
public:
    UnmanagedB() : m_refCount(0) {}
    ~UnmanagedB() {}

    // 引用计数操作
    void AddRef() { m_refCount++; }
    void Release() {
        if (--m_refCount == 0) {
            delete this;
        }
    }

    int i = 0;
private:
    int m_refCount;
};

class UnmanagedA {
public:
    UnmanagedA(UnmanagedB* pUnmanagedB) : m_pUnmanagedB(pUnmanagedB) {
        // 如果UnmanagedA也持有所有权，这里也要增加引用计数
        m_pUnmanagedB->AddRef();
    }
    ~UnmanagedA() {
        m_pUnmanagedB->Release();
    }
    UnmanagedB* B() { return m_pUnmanagedB; }
protected:
    UnmanagedB* m_pUnmanagedB;
};

修改托管包装类： #

public ref class ManagedB : IDisposable {
private:
    UnmanagedB* m_pUnmanagedB;
    bool m_disposed = false;

    void Dispose(bool disposing) {
        if (!m_disposed) {
            if (m_pUnmanagedB != nullptr) {
                m_pUnmanagedB->Release(); // 通知非托管对象减少引用
                m_pUnmanagedB = nullptr;
            }
            m_disposed = true;
        }
    }

public:
    ManagedB(UnmanagedB* pB) : m_pUnmanagedB(pB) {
        pB->AddRef(); // 构造时增加引用计数
    }

    ~ManagedB() {
        Dispose(false);
    }

    virtual void Dispose() sealed = IDisposable::Dispose {
        Dispose(true);
        GC::SuppressFinalize(this);
    }

    // 暴露非托管指针给其他托管类调用
    UnmanagedB* GetUnmanagedPointer() { return m_pUnmanagedB; }
};

public ref class ManagedA : IDisposable {
private:
    UnmanagedA* m_pUnmanagedA;
    bool m_disposed = false;

    void Dispose(bool disposing) {
        if (!m_disposed) {
            if (m_pUnmanagedA != nullptr) {
                delete m_pUnmanagedA; // UnmanagedA的析构会调用UnmanagedB::Release()
                m_pUnmanagedA = nullptr;
            }
            m_disposed = true;
        }
    }

public:
    ManagedA(ManagedB^ managedB) {
        m_pUnmanagedA = new UnmanagedA(managedB->GetUnmanagedPointer());
    }

    ManagedB^ B() {
        // 每次获取都返回新的ManagedB包装，引用计数会自动处理生命周期
        return gcnew ManagedB(m_pUnmanagedA->B());
    }

    ~ManagedA() {
        Dispose(false);
    }

    virtual void Dispose() sealed = IDisposable::Dispose {
        Dispose(true);
        GC::SuppressFinalize(this);
    }
};

优点：非托管层自己控制生命周期，不管多少个托管包装器都不会重复释放；缺点：需要修改非托管类的代码。

2. 托管层维护包装器缓存（适合不想改非托管代码的场景） #

如果没法修改非托管类的代码，那可以在托管层维护一个字典，记录已经创建的托管包装器和对应的非托管指针，避免重复创建。

修改ManagedB类： #

public ref class ManagedB : IDisposable {
private:
    static System::Collections::Generic::Dictionary<IntPtr, ManagedB^>^ s_wrapperCache = 
        gcnew System::Collections::Generic::Dictionary<IntPtr, ManagedB^>();
    static System::Object^ s_lockObj = gcnew System::Object();

    UnmanagedB* m_pUnmanagedB;
    bool m_disposed = false;

    // 私有构造，只能通过静态方法获取实例
    ManagedB(UnmanagedB* pB) : m_pUnmanagedB(pB) {}

    void Dispose(bool disposing) {
        if (!m_disposed) {
            if (m_pUnmanagedB != nullptr) {
                delete m_pUnmanagedB;
                m_pUnmanagedB = nullptr;

                // 从缓存中移除已销毁的包装器
                System::Threading::Monitor::Enter(s_lockObj);
                s_wrapperCache->Remove(IntPtr(m_pUnmanagedB));
                System::Threading::Monitor::Exit(s_lockObj);
            }
            m_disposed = true;
        }
    }

public:
    // 静态方法：获取或创建对应非托管对象的托管包装器
    static ManagedB^ GetWrapper(UnmanagedB* pB) {
        if (pB == nullptr) return nullptr;

        System::Threading::Monitor::Enter(s_lockObj);
        ManagedB^ wrapper;
        if (!s_wrapperCache->TryGetValue(IntPtr(pB), wrapper)) {
            wrapper = gcnew ManagedB(pB);
            s_wrapperCache->Add(IntPtr(pB), wrapper);
        }
        System::Threading::Monitor::Exit(s_lockObj);
        return wrapper;
    }

    ~ManagedB() {
        Dispose(false);
    }

    virtual void Dispose() sealed = IDisposable::Dispose {
        Dispose(true);
        GC::SuppressFinalize(this);
    }

    UnmanagedB* GetUnmanagedPointer() { return m_pUnmanagedB; }
};

修改ManagedA的B()方法： #

ManagedB^ B() {
    return ManagedB::GetWrapper(m_pUnmanagedA->B());
}

优点：不需要修改非托管代码；缺点：需要处理线程安全，而且如果非托管对象被外部销毁（比如非托管层自己delete），缓存里的托管包装器会变成野指针，需要额外的生命周期同步。

3. 明确所有权模型（适合层级清晰的场景） #

如果你的非托管对象有明确的父子关系（比如UnmanagedA是UnmanagedB的所有者），那可以指定只有父级的托管包装器负责释放非托管对象，子级的托管包装器只做“视图”，不负责销毁。

修改ManagedB类： #

public ref class ManagedB {
private:
    UnmanagedB* m_pUnmanagedB;
    bool m_ownsObject; // 标记是否拥有非托管对象的所有权

public:
    // 拥有所有权的构造（仅由所有者托管类调用）
    ManagedB(UnmanagedB* pB, bool ownsObject) : m_pUnmanagedB(pB), m_ownsObject(ownsObject) {}

    // 不拥有所有权的构造（用于返回视图）
    ManagedB(UnmanagedB* pB) : m_pUnmanagedB(pB), m_ownsObject(false) {}

    ~ManagedB() {
        // 只有拥有所有权时才销毁非托管对象
        if (m_ownsObject && m_pUnmanagedB != nullptr) {
            delete m_pUnmanagedB;
            m_pUnmanagedB = nullptr;
        }
    }

    UnmanagedB* GetUnmanagedPointer() { return m_pUnmanagedB; }
};

修改ManagedA： #

public ref class ManagedA : IDisposable {
private:
    UnmanagedA* m_pUnmanagedA;
    ManagedB^ m_ownedB; // 持有拥有所有权的ManagedB实例

public:
    ManagedA(ManagedB^ ownedB) {
        m_ownedB = ownedB;
        m_pUnmanagedA = new UnmanagedA(ownedB->GetUnmanagedPointer());
    }

    ManagedB^ B() {
        // 返回不拥有所有权的视图，避免重复释放
        return gcnew ManagedB(m_pUnmanagedA->B());
    }

    void Dispose() {
        if (m_pUnmanagedA != nullptr) {
            delete m_pUnmanagedA;
            m_pUnmanagedA = nullptr;
        }
        // m_ownedB会由GC自动处理，它的析构会负责销毁UnmanagedB
    }
};

优点：逻辑简单，不需要复杂的计数或缓存；缺点：必须严格遵守所有权规则，一旦误用（比如多个托管对象都声明拥有所有权）还是会出问题。

总结 #

• 如果能修改非托管代码，引用计数是最稳妥的方案，能适配绝大多数场景；
• 如果不能改非托管代码，托管缓存是不错的选择，但要注意线程安全和生命周期同步；
• 如果你的对象层级非常清晰，明确所有权是最简单的方案，能减少额外的复杂度。

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