auto_ptr ou shared_ptr équivalent dans les classes C++/CLI gérées

Question

En C++/CLI, vous pouvez utiliser des types natifs dans une classe managée car il n'est pas autorisé à contenir un membre d'une classe native dans une classe managée: vous devez utiliser des pointeurs dans ce cas.

Voici un exemple:

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 ! 

}; 

Est-ce que quelqu'un sait d'un équivalent de shared_ptr dans le monde C++/CLI?

Editer: Merci pour votre suggestion, "1800-Information". Suite à votre suggestion, j'ai vérifié sur STL.Net mais il est seulement disponible avec Visual Studio 2008, et il fournit des conteneurs + des algorithmes, mais pas de pointeurs intelligents.

Answer 1

J'ai trouvé la réponse sur codeproject:

Nishant Sivakumar a publié un article à ce sujet à http://www.codeproject.com/KB/mcpp/CAutoNativePtr.aspx

Sur cette page, regardez aussi le commentaire de Denis N. Shevchenko: il fournit une implémentation comme stl ça marche plutôt bien.

Answer 2

STL.Net is documented here. Je ne sais pas dans quel état il se trouve ni à quoi cela pourrait servir pour vous.

Answer 3

Je ne l'ai pas testé à fond cela, mais que diriez-vous quelque chose comme ce qui suit:

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

Cela devrait vous permettre d'utiliser les shared_ptrs de C++ 11/Boost interchangebly dans les classes ref.