implementação shared_ptr decente que não requer uma enorme biblioteca?

Question

Eu estou tomando uma classe C ++ programação agora em GIS programação. Estou realmente começando a ficar um monte de dores de cabeça de lidar com o gerenciamento de memória apropriado. Considerando-se a qualquer momento, há muitas vezes 8-10 aulas cada um segurando um ponteiro para uma matriz 3D ou outra coisa muito grande. Agora nossa classe já levantou a questão do prof nos permitir usar Boost, ou pelo menos o C ++ recurso Pack para 2008 (para TR1). Ele se recusou, mas disse que se quiséssemos podemos encontrar adicionar alguns arquivos CPP / HPP terceiros. Eu já tentei olhando para começar shared_ptr fora do impulso, mas isso é mais uma dor de cabeça do que o seu valor.

Então, há alguma espécie de implementação shared_ptr livre lá fora?

Answer 1

Use impulso do bcp ferramenta. Ele permitirá que você extraia uma determinada funcionalidade das bibliotecas de impulso.

bcp shared_ptr /boost_shared_ptr

irá extrair shared_ptr e de dependências para esse diretório.

Answer 2

Lokis ref-contados inteligente ponteiro um tiro -., tanto quanto eu lembro seu menos acoplada então impulsiona cabeçalhos

Answer 3

Preprocess cabeçalho impulso que contém a definição de shared_ptr. Escrevê-lo em um único arquivo .hpp. Desta forma, você vai ter impulso shared_ptr e todas as suas dependências em um arquivo de cabeçalho, sem a necessidade de instalação completa de impulso.

shared_ptr não precisa de nenhuma biblioteca compartilhada para ser ligado ao seu código, é um cabeçalho somente biblioteca ... então isso deve funcionar.

Answer 4

Enquanto isso seria uma terrível idéia para uma solução de produção, não seria muito difícil de rolar o seu próprio para uma classe, se você não tentar ser o compilador cruzado, flexível e thread-safe 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, só vi o seu does not professor permitem que você use TR1. azar.

Answer 6

Você realmente precisa de propriedade que muito compartilhado?

Muitas vezes você pode obter, com apenas uma classe simples ad hoc RAII, tendo a propriedade exclusiva de um objeto.

O gerenciamento de memória sem RAII é uma dor, mas você um RAII get sem shared_ptr.

Answer 7

eu só viu um erro grave em sua amostra de código. Deve ser

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

em vez de

ref_count_(p ? new int : NULL)

o contador deve ser inicializado a 0. se não todos o ponteiro inteligente não é inteligente mais. Todos os programadores que fazem os minúsculos pay erro para ele um monte de depuração mais tarde, você deve pensar como um compilador e agir como ele ....