Murilo :P

C++, Computação, Programação, Web e afins :)

Smart Pointers: Os Ponteiros Espertos do C++

with 2 comments

C++E aí pessoal, como prometido, vou falar sobre Smart Pointers em C++.
Neste post irei abordar smart pointers, o que são, como funcionam e para que são usados, além de mostrar um exemplo de implementação de smart pointers.

1. Introdução:

O que são Smart Pointers?

Smart pointers são implementações feitas para facilitar e ajudar no manuseamento de ponteiros. Para serem mais “inteligentes” que os ponteiros normais, os smart pointers precisam fazer coisas que os ponteiros normais não fazem.
Os smart pointers são objetos que armazenam ponteiros para objetos alocados dinâmicamente (no heap). Eles se comportam como os ponteiros normais do C++ exceto que eles automaticamente deletam o objeto apontado no momento certo. Smart pointers são particularmente úteis para assegurar a destrução apropriada dos objetos dinamicamente alocados em caso de exceções.

Conceitualmente, smart pointres são vistos como dono do objeto apontado, e assim, tem responsabilidade de deleção do objeto quando este não for mais utilizado.

As principais implementações de smart pointers provém facilidades de desalocação automática de memória, ou seja, uma vez que alocamos um smart pointer, não precisamos desalocá-lo. Talvez os erros de programação mais comuns em C++ tenham a ver com manuseamento de memória: memory leaks, ponteiros que não apontam pra dados válidos e outros. Os smart pointers tentam previnir memory leaks pelo recurso de desalocação (deleção) automática: quando um smart pointer sai do seu escopo, o objeto apontado é deletado também.

2. Um Simples Smart Pointer

O exemplo mais simples de smart pointer é o auto_ptr que está incluido na biblioteca do C++. Você pode usá-lo incluindo a header <memory> em seu código. Aqui está uma *parte* da implementação do auto_ptr e explicarei o que ela faz:

 

template <class T> 
class auto_ptr
{
    T* ptr;
public:
    explicit auto_ptr(T* p = 0) : ptr(p) {}
    ~auto_ptr()                 {delete ptr;}
    T& operator*()              {return *ptr;}
    T* operator->()             {return ptr;}
    // ...
};

Como podemos notar, auto_ptr é um simples wrapper de um ponteiro normal. Ele provê as operações importantes de ponteiros (dereferenciamento e indireção). A inteligência desse smart pointer está em seu destrutor: o destrutor é quem cuida de deletar o ponteiro. Exemplo:

Ponteiro normal:

int main()
{
    std::string* str = new std::string("Testando Smart Pointers");
    std::cout << *str << " size: " << str->size() << std::endl;
    delete str;
}

Smart pointer:

int main()
{
    auto_ptr str(new std::string("Testando Smart Pointers"));
    std::cout << *str << " size: " << str->size() << std::endl;
}

3. Benefícios do auto_ptr

Garbage collection. Como o visto no código acima, usando smart pointers que fazem deleção automática, podemos economizar algumas linhas de código. Mas o maior benefício disso é reduzir a probabilidade de ocorrer bugs: você não precisa de lembrar de liberar o espaço alocado.

Limpeza automática. Como o código acima ilustra, usando smart pointers você pode economizar algumas linhas de código por não precisar de chamar delete (ou free) para cada objeto. A importância aqui não é a quantidade de caracteres digitados, mas sim a redução da probabilidade de bugs: não precisa-se de lembrar de deletar o ponteiro.

Inicialização automática. Outra coisa legal é que não precisamos inicializar o auto_ptr como NULL, uma vez que o construtor padrão faz isso por você. Isso é uma coisa a menos para o programador esquecer.

“Dangling pointers”. Um erro comum ao se manusear ponteiros normais é o chamado de “dangling pointer”: um ponteiros que aponta para um objeto já deletado.

Nos próximos posts, iremos ver o quando e alguns outros porquês de se usar smart pointers.

Advertisements

Written by Murilo Adriano

15 de December de 2008 at 14:18

2 Responses

Subscribe to comments with RSS.

  1. Interessante, e bem esclarecedor.
    Vlw pelo post.

    Gabriel Moreira

    17 de December de 2008 at 14:08

  2. Muito bom Murilo!

    Solução muito simples e eficiente. Quero ler os próximos posts. Dá uma passada no meu blog, eu postei sobre a apresentação que fiz sobre GPU.

    Abraço. Div.

    John

    18 de December de 2008 at 23:16


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: