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

Question

En C ++ / CLI, vous pouvez utiliser des types natifs dans une classe gérée car il n'est pas autorisé à détenir un membre d'une classe native dans une classe géré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 !

};

Quelqu'un connaît-il un équivalent de shared_ptr dans le monde C ++ / CLI?

Modifier: Merci pour votre suggestion, "1800-Information". Suivant votre suggestion, j’ai vérifié sur STL.Net, mais il n’est disponible que sous Visual Studio 2008 et fournit des conteneurs + algorithmes, mais pas de pointeurs intelligents.

Answer 1

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

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

Sur cette page, recherchez également le commentaire de Denis N. Shevchenko: il fournit une implémentation stl-like qui fonctionne assez bien.

Answer 2

Je n’ai pas testé cela à fond, mais qu’en est-il de l’un des éléments suivants:

#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 de manière interchangeable dans les classes de référence.

Answer 3

STL.Net est documenté ici . Je ne sais pas dans quel état il se trouve ni à quoi il pourrait servir.