 |
|
Para ver o tutorial anterior da série: Boost Weak Pointer
No tutorial anterior prometi falar sobre arrays, mas resolvi deixar para o próximo tutorial, pois dessa forma já posso incluir o scoped_array.
O Boost Scoped Pointer é uma versão bem simplificada de um smart pointer, que como o nome já diz depende do escopo. Ele é semelhante ao auto_ptr: quando seu destrutor é rodado, o ponteiro que este contém é deletado. A diferença é que o scoped_ptr não pode ser copiado e nem tem um método release (que libera o ponteiro). Ou seja, uma vez inicializado o scoped_ptr, ele se torna dono do ponteiro e vai deletar ele no final da sua vida.
Se o scoped_ptr não pode ser copiado, nem feito release, não pode ser usado com STL (essa não tinha dito ainda), então para que usar ele? Ele é útil quando precisamos alocar um objeto dinamicamente dentro de outro objeto ou quando precisamos de algo dinâmico dentro de algum escopo.
Por exemplo:
#include <boost/scoped_ptr.hpp>
int main(int, char **argv)
{
boost::scoped_ptr<Person> p(new Person());
p->SetName("Bruno");
return(0);
}
Basicamente é o mesmo exemplo dos programas anteriores, a diferença é que o scoped_ptr, diferentemente do shared_ptr não precisa alocar um outro objeto para gerenciar contagem de referencias, dessa forma ele permite que qualquer compilador descente, consiga pegar o código acima e gerar:
int main(int, char **argv)
{
Person *p(new Person);
p->SetName("Bruno");
delete p;
return(0);
}
Ou seja, o scoped_ptr não tem custo algum em tempo de execução! Claro que o exemplo acima é bem simples, e o ideal seria criar a classe Person na pilha. Vamos tentar outro exemplo…
Imaginemos que temos um programa de processamento de imagens, e este programa possui uma classe para realizar operações com uma imagem, como imagens geralmente consomem muitos recursos, não é desejável que a classe de operações possua uma imagem como atributo, e como a imagem não vai ser compartilhada, podemos usar uma scoped_ptr:
#include <boost/scoped_ptr.hpp>
#include <string>
class Image
{
public:
int Load(const std::string &name)
{
//implementacao
return 0;
}
};
class ImageOperation
{
public:
int Load(const std::string &name)
{
m_image.reset(new Image());
return(m_image->Load(name));
}
private:
boost::scoped_ptr<Image> m_image;
};
int main(int argc, char **argv)
{
ImageOperation op;
op.Load("teste.bmp");
return 0;
}
Nesse exemplo simples vimos que usando um scoped_ptr não precisamos nos preocupar mais com gerenciamento de ponteiros, pois o scoped_ptr garante que todo ponteiro armazenado por ele vai ser desalocado. Esta é uma dos smart pointers mais fáceis e práticos de se usar, inclusive para quem viu o Google C++ Style Guide, ele esta na lista de recomendações.
No próximo tutorial, vamos ver finalmente como lidar com arrays (o scoped_ptr também não serve para arrays).
Próximo tutorial da série: Boost Shared Array e Scoped Array
