C++/CLI 包装返回 std::shared_ptr 的函数

Question

我目前正在使用 C++/CLI 包装 C++ 类，以实现 .NET 互操作性，遵循在托管类中保存本机指针的标准流程。在一个实例中，我有一个本机类，其功能如下：

std::shared_ptr<BaseChannel> channelData(const int RunNumber);

我已经开始为 BaseChannel 创建一个包装类。但是，如果我将原始指针传递给托管类的构造函数，则无法保证托管类所指向的对象的生命周期。即，shared_ptr 可能超出范围，对象将被删除，托管类将保留一个悬空指针。

对于这种情况，常见的解决方案是什么？

更新

@Ben：所以我像这样包装了保存上述问题中方法的类（假设它位于一个名为 Node 的本机类中，并且它被包装在一个名为 NodeRef 的托管类：

ChannelUser^ NodeRef::ChannelData(int runNumber)
{
    // mpNode is native class pointer of type Node held in managed class
    // wrapper called NodeRef
    std::shared_ptr<BaseChannel> spBaseChannel = mpNode->channelData(runNumber);

    // ChannelUser is using clr_scoped_ptr to hold the shared_ptr
    ChannelUser^ channelUser = gcnew ChannelUser(spBaseChannel);
    return channelUser;
}

因为当通过引用传递给托管类时，shared_ptr 的引用计数没有增加，这是否意味着

只要这个shared_ptr在 范围，它指向的对象将 仍然存在，因为它的参考 计数至少为 1

? (ref C++ - 传递对 std::shared_ptr 或 boost::shared_ptr 的引用 ）

Answer 1

这是一个托管的 shared_ptr。您可以直接从 shared_ptr 分配给它，它会获取一个副本，当托管对象被 GC 或处置时，它将删除该副本。

示例：

m_shared_ptr<CupCake> cupCake0(new CupCake());
m_shared_ptr<CupCake> cupCake1 = new CupCake();
m_shared_ptr<CupCake> cupCake2 = shared_ptr<CupCake>(new CupCake());
m_shared_ptr<CupCake> cupCake3 = make_shared<CupCake>();
shared_ptr<CupCake> cupCake4 = (shared_ptr<CupCake>)cupCake3;

代码：

#pragma once

#include <memory>

template <class T>
public ref class m_shared_ptr sealed
{
    std::shared_ptr<T>* pPtr;

public:
    m_shared_ptr() 
        : pPtr(new std::shared_ptr<T>()) 
    {}

    m_shared_ptr(T* t) {
        pPtr = new std::shared_ptr<T>(t);
    }

    m_shared_ptr(std::shared_ptr<T> t) {
        pPtr = new std::shared_ptr<T>(t);
    }

    m_shared_ptr(const m_shared_ptr<T>% t) {
        pPtr = new std::shared_ptr<T>(*t.pPtr);
    }

    !m_shared_ptr() {
        delete pPtr;
    }

    ~m_shared_ptr() {
        delete pPtr;
    }

    operator std::shared_ptr<T>() {
        return *pPtr;
    }

    m_shared_ptr<T>% operator=(T* ptr) {
        delete pPtr;
        pPtr = new std::shared_ptr<T>(ptr);
        return *this;
    }

    T* operator->() {
        return (*pPtr).get();
    }

    void reset() {
        pPtr->reset();
    }
};

Answer 2

shared_ptr 是本机类型，托管对象不能具有完整的本机子对象。

但是，正如您所注意到的，托管对象可以具有指向本机对象的指针。您需要的是一个指向 shared_ptr 的指针，它将被视为对 BaseChannel 对象的引用，并防止其过早释放。

当然，使用智能指针而不是原始 shared_ptr* 的原因有很多。我写了一个应该合适的智能指针，你可以在 codereview.stackexchange.com 上找到它： “C++/CLI 的scoped_ptr（确保托管对象正确释放拥有的本机对象）”

---

示例（未编译已测试）：

ref class ChannelUser
{
    clr_scoped_ptr<shared_ptr<BaseChannel>> chan_ptr;

public:
    ChannelUser( shared_ptr<BaseChannel>& chan ) : chan_ptr(new shared_ptr<BaseChannel>(chan)) {}
};

这会自动实现 IDisposable 并在 Dispose 或终结器运行时删除 shared_ptr，从而减少 shared_ptr 上的引用计数>基本频道。