auto_ptr o shared_ptr equivalente en gestionadas clases C++/CLI

Question

En C++/CLI, se pueden utilizar los tipos nativos en una clase administrada por ella no se le permite mantener un miembro de una clase nativa en una clase administrada: es necesario utilizar punteros en ese caso.

Aquí se muestra un ejemplo:

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 ! 

}; 

¿Alguien sabe de un equivalente de shared_ptr en el mundo C++/CLI?

Editar: Gracias por su sugerencia, "1800-información". Siguiendo su sugerencia, consulté sobre STL.Net pero solo está disponible con Visual Studio 2008, y proporciona contenedores + algoritmos, pero no punteros inteligentes.

Answer 1

he encontrado la respuesta en codeproject:

Nishant Sivakumar publicó un artículo sobre esto en http://www.codeproject.com/KB/mcpp/CAutoNativePtr.aspx

En esta página, también se ven por el comentario de Denis N. Shevchenko: se proporciona una implementación similar a STL eso funciona bastante bien

Answer 2

STL.Net is documented here. No sé en qué estado está o qué utilidad podría ser para usted.

Answer 3

no he probado a fondo esto, pero ¿qué tal algo como lo siguiente:

#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(); 
    } 
}; 

Esto debería permitir que utiliza shared_ptrs C++ 11/Boost de interchangebly en las clases de ref.