Implementazione decente di shared_ptr che non richiede una libreria enorme?

Question

Sto frequentando un corso di programmazione C++ in questo momento sulla programmazione GIS.Sto davvero iniziando ad avere un sacco di mal di testa a causa della corretta gestione della memoria.Considerando che in qualsiasi momento ci sono spesso 8-10 classi ciascuna che contiene un puntatore a una matrice 3D o qualcos'altro di molto grande.Ora la nostra classe ha già sollevato la questione se il prof ci permettesse di utilizzare Boost, o almeno il Feature Pack C++ per il 2008 (per TR1).Ha rifiutato ma ha detto che se volevamo possiamo aggiungere alcuni file cpp/hpp di terze parti.Ho già provato a cercare di far uscire shared_ptr dal boost, ma è più un mal di testa che il suo valore.

Quindi esiste qualche tipo di implementazione shared_ptr gratuita là fuori?

Answer 1

Usa spinta di BCP attrezzo. Essa ti consente di estrarre alcune funzionalità dalle librerie boost.

bcp shared_ptr /boost_shared_ptr

sarà estratto shared_ptr ed è dipendenze a quella directory.

Answer 2

Lokis ref-contato puntatore intelligente un colpo -. per quanto mi ricordo il suo meno accoppiato quindi aumenta le intestazioni

Answer 3

Preprocessa intestazione spinta che contiene la definizione di shared_ptr. Scriverlo in un singolo file .hpp. In questo modo si otterrà spinta shared_ptr e tutte le sue dipendenze in un unico file di intestazione, senza la necessità di installazione completa di spinta.

shared_ptr non necessita di alcuna libreria condivisa per essere collegato al codice, è una libreria header-solo ... quindi questo dovrebbe funzionare.

Answer 4

Mentre sarebbe un terribile idea per una soluzione di produzione, non sarebbe troppo difficile da rotolare il proprio per una classe, se non cercare di essere compilatore come croce, flessibili e thread-safe come spinta di:

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, appena visto il tuo professore doesnt consentono di utilizzare TR1. fortuna dura.

Answer 6

avete veramente bisogno di proprietà che molto condiviso?

Spesso è possibile cavarsela con una semplice hoc classe Raii annuncio, prendendo la proprietà esclusiva di un oggetto.

La gestione della memoria, senza RAII è un dolore, ma è un RAII GET senza shared_ptr.

Answer 7

Ho appena notato un grave errore nel tuo esempio di codice.Dovrebbe essere

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

invece di

ref_count_(p ? new int : NULL)

il contatore dovrebbe essere inizializzato su 0.altrimenti tutto il tuo puntatore intelligente non è più intelligente.Tutti quei programmatori che fanno quei piccoli errori pagano molto per il debug in seguito, dovresti pensare come un compilatore e comportarsi così ...