auto_ptr o shared_ptr equivalente nelle classi C ++ / CLI gestite

Question

In C ++ / CLI, è possibile utilizzare tipi nativi in ??una classe gestita in quanto non è consentito contenere un membro di una classe nativa in una classe gestita: in tal caso è necessario utilizzare i puntatori.

Ecco un esempio:

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 !

};

Qualcuno conosce un equivalente di shared_ptr nel mondo C ++ / CLI?

Modifica: Grazie per il tuo suggerimento, "1800-Informazioni". Seguendo il tuo suggerimento, ho controllato STL.Net ma è disponibile solo con Visual Studio 2008 e fornisce contenitori + algoritmi, ma nessun puntatore intelligente.

Answer 1

Ho trovato la risposta su codeproject :

Nishant Sivakumar ha pubblicato un articolo a riguardo su http://www.codeproject.com /KB/mcpp/CAutoNativePtr.aspx

In questa pagina, cerca anche il commento di Denis N. Shevchenko: fornisce un'implementazione di tipo stl che funziona abbastanza bene.

Answer 2

Non l'ho ancora testato a fondo ma che ne dici di qualcosa del tipo:

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

Questo dovrebbe permetterti di usare C ++ 11 / Boost's shared_ptrs in modo intercambiabile nelle classi ref.

Answer 3

STL.Net è documentato qui . Non so in che stato si trova o che uso potrebbe essere per te.