Auto_ptr o shared_ptr equivalente en clases administradas de C ++ / CLI

Question

En C ++ / CLI, puede usar tipos nativos en una clase administrada ya que no está permitido mantener a un miembro de una clase nativa en una clase administrada: necesita usar punteros en ese caso.

Aquí hay 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 de C ++ / CLI?

Editar: Gracias por tu sugerencia, " 1800-Information " ;. Siguiendo su sugerencia, verifiqué acerca de STL.Net, pero solo está disponible con Visual Studio 2008 y proporciona contenedores + algoritmos, pero no punteros inteligentes.

Answer 1

Encontré 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 busque el comentario de Denis N. Shevchenko: proporciona una implementación de tipo STL que funciona bastante bien.

Answer 2

No he probado esto a fondo, 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 permitirte usar las acciones compartidas de C ++ 11 / Boost de manera intercambiable en las clases ref.

Answer 3

STL.Net se documenta aquí . No sé en qué estado se encuentra o qué uso podría tener para usted.