aplicación shared_ptr decente que no requiere una gran biblioteca?

Question

Estoy tomando una clase de C ++ de programación en este momento en la programación SIG. Realmente estoy empezando a tener un montón de dolores de cabeza de tratar con la gestión de memoria adecuada. Teniendo en cuenta en todo momento existe a menudo 8-10 clases cada uno sosteniendo un puntero a una matriz 3D o alguna otra cosa muy grande. Ahora nuestra clase ya se planteó la cuestión de la prof permitirnos usar Boost, o al menos el paquete de características de C ++ para el año 2008 (por TR1). Se negó, pero dijo que si queríamos podemos encontrar agregar algunos archivos cpp / HPP terceros. Ya he intentado buscando en conseguir shared_ptr de impulso, pero que es más de un dolor de cabeza de lo que vale.

Entonces, ¿hay algún tipo de aplicación shared_ptr libre por ahí?

Answer 1

BCP herramienta. Se le permitirá extraer cierta funcionalidad de las bibliotecas Boost.

bcp shared_ptr /boost_shared_ptr

extraerá shared_ptr y sus dependencias a ese directorio.

Answer 2

Lokis puntero inteligente ref-contado un tiro -. Por lo que yo recuerdo sus menos acoplada a continuación, aumenta cabeceras

Answer 3

cabecera impulso de preproceso que contiene la definición de shared_ptr. Escribirla en un solo archivo .hpp. De esta manera se conseguirá shared_ptr impulso y todas sus dependencias en un archivo de cabecera, sin la necesidad de la instalación completa del impulso.

shared_ptr no necesita ninguna biblioteca compartida estar relacionado con su código, es una biblioteca sólo de encabezado ... así que esto debería funcionar.

Answer 4

Si bien sería una terribles idea para una solución de producción, no sería demasiado difícil de rodar su propia para una clase, si no se trata de ser como compilador, flexibles y el hilo de seguridad como impulso de:

template <typename contained>
class my_shared_ptr {
public:
   my_shared_ptr() : ptr_(NULL), ref_count_(NULL) { }

   my_shared_ptr(contained * p)
     : ptr_(p), ref_count_(p ? new int : NULL)
   { inc_ref(); }

   my_shared_ptr(const my_shared_ptr& rhs)
     : ptr_(rhs.p), ref_count_(rhs.ref_count_)
   { inc_ref(); }

   ~my_shared_ptr() {
     if(ref_count_ && 0 == dec_ref()) { delete ptr_; delete ref_count_; }
   }
   contained * get() { return ptr_; }
   const contained * get() const { return ptr_; }

   void swap(my_shared_ptr& rhs) // throw()
   {
      std::swap(p, rhs.p);
      std::swap(ref_count_, rhs.ref_count_);
   }

   my_shared_ptr& operator=(const my_shared_ptr& rhs) {
        my_shared_ptr tmp(rhs);
        this->swap(tmp);
        return *this;
   }

   // operator->, operator*, operator void*, use_count
private:
   void inc_ref() {
      if(ref_count_) { ++(*ref_count_); }
   }

   int  dec_ref() {
      return --(*ref_count_);
   }

   contained * ptr_;
   int * ref_count_;
};

Answer 5

#include <tr1/memory> // this is contained in STL.
std::tr1::shared_ptr<A> a = new A;

ow, acabo de ver a su profesor No permite que usted utilice TR1. Mala suerte.

Answer 6

lo que realmente necesita la propiedad compartida tanto?

A menudo se puede llegar a funcionar con sólo un simple anuncio hoc clase RAII, teniendo la propiedad exclusiva de un objeto.

La gestión de memoria sin RAII es un dolor, pero una RAII conseguir sin shared_ptr.

Answer 7

Yo sólo vi un grave error en su código de ejemplo. Debe ser

ref_count_(p ? new int(0) : NULL)

en lugar de

ref_count_(p ? new int : NULL)

el contador debe ser inicializado a 0. si no todo el puntero inteligente no es inteligente más. Todos aquellos programadores que hacen los diminuta pago error para que sea mucho más tarde, en la depuración usted debe pensar como un compilador y actuar como si ....