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

如何解决C ++ / CLI包装了一个返回std :: shared_ptr的函数

|| 我目前正在按照在托管类中保留本机指针的标准过程，使用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 ？ （参考C ++-传递对std :: shared_ptr或boost :: shared_ptr的引用）     

解决方法

        

shared_ptr

是本机类型，并且托管对象不能具有完整的本机子对象。 但是，请注意，托管对象可以具有指向本机对象的指针。您需要一个指向

shared_ptr

的指针，该指针将被视为对to1ѭ对象的引用，并防止其过早释放。 当然，有很多理由使用智能指针而不是原始的“ 7”。我已经编写了一个适合的智能指针，可以在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

，从而减少了

BaseChannel

上的引用计数。     ,        这是托管的

shared_ptr<T>

。您可以直接从ѭ4分配它，它将获得一个副本，当对受管对象进行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();
    }
};