você está aqui: Home  → Arquivo de Mensagens

Usando a biblioteca smart_ptr do boost

Colaboração: Felipe Magno de Almeida

Data de Publicação: 12 de Junho de 2006

Para quem programa dia-a-dia em C++ sabe como trabalhar com ponteiros é uma tarefa entediante e dificil de acertar, principalmente de primeira.

A coleção de bibliotecas boost possui uma biblioteca que ajuda incrivelmente na produtividade e corretude de códigos que utilizam ponteiros, essa biblioteca se chama smart_ptr.

Smart_ptrs são conhecidos há alguns tempos e são um idiom para que facilita a automatização de ações sobre ponteiros, sendo a mais usada o gerenciamento de tempo de vida.

  int main()
  {
    int* p = new int(10);
  }

O código acima possui um memory leak. Apesar desse código ser simples e facilmente corrigido, deletando o objeto logo depois do uso, é bem comum em sistemas maiores que objetos sejam compartilhados entre várias partes do código. Isso torna o gerenciamento do tempo de vida do objeto muito difícil e um fardo para o programador, que já tem muito com o que se preocupar.

Um smart pointer nada mais é do que uma class template parametrizada no tipo do objeto ao qual ele deve apontar com os operadores usados nos ponteiros sobrecarregados para ele de forma a imitar a sintaxe de um ponteiro comum.

Para instalar o boost de forma que seja possível fazer uso da biblioteca smart_ptr é bem simples. Basta carregar o conjunto de bibliotecas da página links http://www.boost.org e descompactá-la em algum lugar.

Como a biblioteca smart_ptr é header-only, não é necessário compilar o boost para usá-la. Basta incluir no caminho dos includes de headers o caminho do boost e começar a usar. Se você estiver usando o gcc e tiver descompactado o boost em /boost é só incluir na linha de comando do g++ o seguinte:

```-I/boost

Na biblioteca smart_ptr existem vários smart pointers, porém explicarei somente o mais importante, que é o shared_ptr.

Como todas as bibliotecas existentes no boost estão no namespace boost, o shared_ptr será sempre prefixado com namespace::.

Veja um exemplo usando o shared_ptr.

  #include <boost/shared_ptr.hpp> // inclui boost::shared_ptr
  #include <iostream>
  
  struct A
  {
    A() { std::cerr << "construtor de A" << std::endl; }
    ~A() { std::cerr << "destrutor de A" << std::endl; }
  };
  
  class B
  {
    boost::shared_ptr<A> p_;
  public:
    B(boost::shared_ptr<A> p)
      : p_(p) // atribui a p_ o argumento p
    {}
  };
  
  void foo(boost::shared_ptr<A> p)
  {
    boost::shared_ptr<B> p1(new B(p));
  }
  
  int main()
  {
    boost::shared_ptr<A> p(new A);
    foo(p);
  }

Para compilar é só usar o seguinte comando:

```g++ arquivo.cpp -o teste -I/boost

Conclusão

Não é porque você pode gerenciar manualmente o tempo de vida de seus objetos que você deva ou precisa fazer isso. Smart pointers são uma forma de Resource Acquisition Is Initialization, amplamente divulgado por Bjarne Stroustrup que não só facilita a codificação que faça uso de recursos diversos como torna o código mais elegante e sucinto.



Veja a relação completa dos artigos de Felipe Magno de Almeida

 

 

Opinião dos Leitores

Seja o primeiro a comentar este artigo
*Nome:
Email:
Me notifique sobre novos comentários nessa página
Oculte meu email
*Texto:
 
  Para publicar seu comentário, digite o código contido na imagem acima
 


Powered by Scriptsmill Comments Script