Decent Shared_ptr Implementierung, die nicht über eine riesige Bibliothek benötigen?

Question

Ich nehme eine C ++ Klasse Programmierung jetzt auf GIS-Programmierung. Ich fange wirklich eine Menge Kopfschmerzen zu bekommen von mit dem richtigen Speicherverwaltung zu tun. Betrachtet man jederzeit gibt es oft 8-10 Klassen jeweils einen Zeiger auf eine 3D-Matrix oder etwas anderes sehr groß zu halten. Jetzt ist unsere Klasse hob bereits die Frage der prof ermöglicht es uns, Boost zu verwenden, oder zumindest die C ++ Feature Pack für das Jahr 2008 (für TR1). Er lehnte ab, sagte aber, wenn wir wollten wir ein paar Dritte CPP / HPP-Dateien hinzufügen finden. Ich habe bereits versucht, Blick auf Shared_ptr immer aus Schub, aber das ist eher Kopfschmerzen als sein Wert.

So ist es eine Art freier Shared_ptr Implementierung da draußen?

Answer 1

Mit boost bcp Werkzeug. Es wird Ihnen eine bestimmte Funktionalität aus den Boost-Bibliotheken zu extrahieren.

bcp shared_ptr /boost_shared_ptr

wird Shared_ptr extrahieren und die Abhängigkeiten in dieses Verzeichnis.

Answer 2

Lokis ref gezählt Smart-Pointer ein Schuss -. soweit ich erinnere an seinem weniger gekoppelt dann steigert Header

Answer 3

Preprocess Boost-Header, der die Definition von shared_ptr enthält. Schreiben Sie es auf eine einzige .hpp Datei. Auf diese Weise werden Sie boost shared_ptr erhalten und alle seine Abhängigkeiten in einer Header-Datei, ohne die Notwendigkeit einer vollständigen Installation von Schub.

shared_ptr keine Shared Library benötigt, um Ihren Code verknüpft werden, ist es eine Kopf nur Bibliothek ... so sollte diese Arbeit.

Answer 4

Während es eine schrecklich Idee für eine Produktionslösung wäre, wäre es nicht zu hart sein, eigene für eine Klasse zu rollen, wenn Sie nicht als Cross-Compiler zu sein versuchen, flexibel und Faden sicher wie boost suchen:

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, nur sah Ihr Professor doesnt erlauben Sie TR1 zu verwenden. Pech.

Answer 6

Haben Sie wirklich brauchen Besitz geteilt, dass viel?

Sie können oft erhalten, indem mit nur einer einfachen Ad-hoc-RAH-Klasse unter exklusivem Besitz eines Objekt.

Speicherverwaltung ohne RAII ist ein Schmerz, aber Sie eine get RAII ohne shared_ptr.

Answer 7

Ich entdeckte gerade einen schweren Fehler im Code Probe. Es sollte sein

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

statt

ref_count_(p ? new int : NULL)

der Zähler soll auf 0 initialisiert werden. wenn nicht alle Ihre Smart-Pointer ist nicht mehr intelligent. All jene Programmierer, die die winzigen Fehler zahlen Sie für es viel später debuggen, Sie sollte wie ein Compiler denken und handeln wie es ....