Ponteiro inteligente: diferenças entre revisões
Substitui a referência a std::auto_ptr que é uma classe que esta deprecated por std::unique_ptr e std::shared_ptr. |
Removida menção a iteradores como smart pointers já que são conceitos diferentes no padrão. |
||
Linha 7: | Linha 7: | ||
== Uso prático == |
== Uso prático == |
||
Em [[C++]], um ponteiro inteligente pode ser implementado como uma [[classe (programação)|classe]] que simula o comportamento de ponteiros tradicionais, através do uso de sobrecarga de operadores, mas cujo funcionamento interno ([[encapsulamento|encapsulado]]) é mais sofisticado |
Em [[C++]], um ponteiro inteligente pode ser implementado como uma [[classe (programação)|classe]] que simula o comportamento de ponteiros tradicionais, através do uso de sobrecarga de operadores, mas cujo funcionamento interno ([[encapsulamento|encapsulado]]) é mais sofisticado. A própria biblioteca padrão declara no cabeçalho <code><memory></code> os ponteiros inteligentes <code>std::unique_ptr</code> e <code>std::shared_ptr</code>. |
||
== Exemplo == |
== Exemplo == |
Revisão das 19h47min de 31 de maio de 2015
Em ciência da computação, um ponteiro inteligente (também conhecido pelo termo em língua inglesa smart pointer) é um tipo de dado abstrato que simula um ponteiro. Ele fornece mais funcionalidades que ponteiros, como coletor de lixo ou verificação de limites do tipo de dado, para adicionar segurança e reduzir erros de programação, ainda que maximizando a eficiência. Implementações de ponteiros inteligentes geralmente possuem referência aos objetos que apontam por questões de gerenciamento de memória. Do ponto de vista de padrões de projeto de software, um ponteiro inteligente é um proxy para uma interface de ponteiro.
Contagem de referências
O uso de ponteiros pode ser fonte de erros de programação, como o vazamento de memória. Ponteiros inteligentes podem ser usados para prevenir esse problema ao tornar a desalocação do recurso um procedimento automático. Quando o ponteiro de um objeto é destruído, ou ainda o último ponteiro de uma série apontando para o mesmo objeto, o objeto apontado é também destruído. Seu funcionamento interno pode variar, com técnicas que variam desde contagem de referências ao objeto ou a atribuição da propriedade de um objeto a um único ponteiro.
Uso prático
Em C++, um ponteiro inteligente pode ser implementado como uma classe que simula o comportamento de ponteiros tradicionais, através do uso de sobrecarga de operadores, mas cujo funcionamento interno (encapsulado) é mais sofisticado. A própria biblioteca padrão declara no cabeçalho <memory>
os ponteiros inteligentes std::unique_ptr
e std::shared_ptr
.
Exemplo
Em C++, seja SmartPointer<X>
uma classe de ponteiro inteligente especializada para a classe X
:
void teste_de_ponteiro_inteligente()
{
// Cria-se dois objetos e mantém-se ponteiros tradicionais para referenciá-los
Object* obj_1 = new Object();
Object* obj_2 = new Object();
// Declara-se dois ponteiros inteligentes e associa-se aos objetos alocados anteriormente
// A contagem interna de referências para obj_1 e obj_2 será 1
SmartPointer<Object> p = obj_1;
SmartPointer<Object> q = obj_2;
// Atribui-se p a q, o que torna a contagem interna de referência a obj_1 igual a 2
// obj_2 será destruído já que a contagem de referências chega a 0
q = p;
// Atribui-se nulo a q. A contagem de obj_1 retorna a 1
q = NULL;
// Cria-se novo objeto e atribui-se diretamente a p
// obj_1 é destruído
p = new Object();
// Cria-se outro objeto e atribui-se a um ponteiro tradicional
// Na perda de escopo do ponteiro, obj_3 será perdido e haverá vazamento de memória
Object* obj_3 = new Object();
}