Punteros inteligentes en C++ (smart pointers)

Para mucha gente, la lacra de programar en C/C++ frente a otros lenguajes es el tener que liberar memoria y controlar donde se libera ésta. Es cierto que el control que dan estos lenguajes al programador es mucho y permite hacer cosas magnificas, pero hay que reconocerlo: somos vagos. En este sentido, se puede hacer en C++ una cosa denominada punteros inteligentes que pueden liberar memoria cuando esta ya no sea necesaria.

Los punteros inteligentes son un tipo de clase que haciendo uso de plantillas son capaces de comportarse como punteros y, segun su implementación, liberar la memoria cuando haga falta. Por contra, esto supone un decremento del rendimiento de la aplicación que habrá que considerar antes de utilizarlos.

Hay una gran cantidad de implementaciones en internet, pero aquí sólo me voy a centrar en la idea básica de todas ellas. Para empezar podemos considerar tres tipos de políticas de manejo de punteros:

  • Agresivas: que consisten en mantener un contador de copias por cada puntero en el sistema (es el mecanismo más lento).
  • Simple: sólo se considera un puntero, no puede asignarse a otros, por lo que no se necesita ningún tipo de contador (es el mecanismo más rápido).
  • Intermedio: cualquier política de uso que se encuentre entre simple y agresiva (su rendimiento será dependiente del tipo de política).

Como ejemplo de puntero que sigue una política simple podemos considerar el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
* PtrSimple permite el manejo de la memoria de forma sencilla dentro de un cuerpo de sentencias.
* Los punteros manejados por el no deben ser liberados por el programador ni deberían utilizarse
* de otro modo que no sea a través de esta clase.
*/
template<typename _T> class PtrSimple {
private:
   _T *_ptr;
 
public:
   PtrSimple( _T* ptr = NULL ) {
      _ptr = ptr;
   }
   ~PtrSimple() {
      if( _ptr != NULL )
         delete _ptr;
   }
 
   T* operator->() {
      return _ptr;
   }
 
   T& operator*() {
      return *_ptr;
   }
};
// Esto es para que no me falle en wordpress :P : </typename>

Sin duda este es el tipo de puntero más sencillo que se puede hacer, ya que sólo controla un único puntero, no pudiendo ser asignado a otra clase, lo que limita mucho sus posibilidades a su uso en un único método. A partir de este se puede empezar a trabajar para añadirle funcionalidades (cosa que dejaré para otra entrada).

De momento lo dejo aquí para no alargar más la cosa. A ver si en un par de días saco otro artículo para seguir con el tema. Ahora a esperar que ferdy me crucifique :P

Un comentario en “Punteros inteligentes en C++ (smart pointers)

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *