Usando a biblioteca smart_ptr do boost
======================================
Colaboração: Felipe Magno de Almeida
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 (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
// inclui boost::shared_ptr
#include
struct A
{
A() { std::cerr << "construtor de A" << std::endl; }
~A() { std::cerr << "destrutor de A" << std::endl; }
};
class B
{
boost::shared_ptr p_;
public:
B(boost::shared_ptr p)
: p_(p) // atribui a p_ o argumento p
{}
};
void foo(boost::shared_ptr p)
{
boost::shared_ptr p1(new B(p));
}
int main()
{
boost::shared_ptr 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.