auto_ptr oder shared_ptr Äquivalent in verwalteten C++/CLI-Klassen

Question

In C++/CLI können Sie native Typen in einer verwalteten Klasse verwenden, indem ein Member einer nativen Klasse in einer verwalteten Klasse nicht enthalten ist: Sie müssen Zeiger verwenden In diesem Fall. Hier

ein Beispiel:

class NativeClass 
{ 
.... 
}; 


public ref class ManagedClass 
{ 
private: 
    NativeClass mNativeClass; // Not allowed ! 

    NativeClass * mNativeClass; // OK 

    auto_ptr<NativeClass> mNativeClass; //Not allowed ! 
    boost::shared_ptr<NativeClass> mNativeClass; //Not allowed ! 

}; 

Kennt jemand ein Äquivalent von shared_ptr in der C++/CLI Welt?

Bearbeiten: Danke für Ihren Vorschlag, "1800-Information". Ihrem Vorschlag folgend, habe ich über STL.Net nachgesehen, aber es ist nur mit Visual Studio 2008 verfügbar und bietet Container + Algorithmen, aber keine Smart Pointer.

Answer 1

ich die Antwort auf codeproject fand er eine stl artige Umsetzung das funktioniert ganz gut.

Answer 2

STL.Net is documented here. Ich weiß nicht, in welchem ​​Zustand es ist oder welcher Nutzen es für dich sein könnte.

Nishant Sivakumar veröffentlichte einen Artikel über diesen bei http://www.codeproject.com/KB/mcpp/CAutoNativePtr.aspx

Auf dieser Seite sieht auch für den Kommentar von Denis N. Shevchenko:

Answer 3

Ich habe nicht gründlich getestet dies aber wie wäre es so etwas wie die folgenden:

#pragma once 

#include <memory> 

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

public: 
    m_shared_ptr() 
     : pPtr(nullptr) 
    {} 

    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) { 
     pPtr = new std::shared_ptr<T>(ptr); 
     return *this; 
    } 

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

Dies sollte man nimmt C++ 11/Boost des shared_ptrs interchangebly in ref Klassen.