la mise en œuvre de shared_ptr décent qui ne nécessite pas une énorme bibliothèque?

StackOverflow https://stackoverflow.com/questions/1512520

  •  19-09-2019
  •  | 
  •  

Question

Je prends une classe de programmation C ++ en ce moment sur la programmation SIG. Je commence vraiment obtenir beaucoup de maux de tête face à la gestion de la mémoire appropriée. Considérant à tout moment, il est souvent 8-10 classes chacune tenant un pointeur vers une matrice 3D ou quelque chose d'autre très grand. Maintenant, notre classe déjà soulevé la question du prof nous permettant d'utiliser Boost, ou du moins le Feature Pack C ++ pour 2008 (pour TR1). Il a refusé mais a dit que si nous voulions nous pouvons trouver ajouter quelques tiers fichiers cpp / HPP. Je l'ai déjà essayé de regarder obtenir shared_ptr sur coup de pouce, mais qui est plus d'un mal de tête que sa valeur.

Donc, il y a une sorte de mise en œuvre de shared_ptr gratuit là-bas?

Autres conseils

ref compté pointeur intelligent Lokis un tir -. Pour autant que je me rappelle son moins couplé augmente alors les en-têtes

Prétraitement tête de boost qui contient la définition de shared_ptr. Ecrire à un seul fichier .hpp. De cette façon, vous aurez boost shared_ptr et toutes ses dépendances dans un fichier d'en-tête, sans qu'il soit nécessaire pour l'installation complète de boost.

shared_ptr n'a pas besoin de bibliothèque partagée être liée à votre code, il est une bibliothèque d'en-tête seulement ... ce qui devrait fonctionner.

Alors qu'il serait terribles idée d'une solution de production, il ne serait pas trop difficile de rouler votre propre pour une classe, si vous ne l'avez pas essayer d'être compilateur croix, flexible et thread-safe comme de boost: 

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_;
};

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

OW, juste vu votre professeur ne marche pas vous permettre d'utiliser TR1. chance.

Avez-vous vraiment besoin partagiez la propriété tant que ça?

Vous pouvez souvent obtenir avec juste une simple classe RAII ad hoc, en propriété exclusive d'un objet.

Gestion de la mémoire sans RAII est une douleur, mais vous un RAII get sans shared_ptr.

Je viens repéré une grave erreur dans votre exemple de code. Il devrait être 

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

au lieu de 

ref_count_(p ? new int : NULL)

le compteur doit être initialisé à 0. sinon la totalité de votre pointeur intelligent est pas intelligent plus. Tous les programmeurs qui font ces minuscules salaire d'erreur pour elle beaucoup dans le débogage plus tard, vous devez penser comme un compilateur et d'agir comme il ....

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top