Poco C++

// ----------------------------------------------------------------------------
// Reference counting (Conteo de referencias)
// ----------------------------------------------------------------------------

Es una técnica para contabilizar las veces que un determinado recurso está siendo referido.

La técnica permite establecer cuando no existe ninguna referencia a un recurso y éste puedeser liberado.

Tiene una importante desventaja, si las referencias forman un ciclo los objetos involucrados no se liberarán nunca.

- Cada vez que una referencia se destruye o se sobrescriban, el contador e decrementa.
- Siempre que se crea o se copia una referencia, el contador se incrementa.
- Inicialmente el contador vale 1.
- Cuando el contador llega a cero, el recurso es destruido.- En un escenario multiproceso, las operaciones de incrementar y decrementar deben ser atómicas.

// ----------------------------------------------------------------------------
// La propiedad de objetos (Object Ownership)
// ----------------------------------------------------------------------------

Si alguien toma la propiedad de un recurso, es el responsable de eliminarlo cuando nosea necesario.

Si el propietario del objeto no puede liberarlo se producirá una pérdida de memoria.
Otros prodán referenciar el objeto pero nunca deberían destruirlo.
La propiedad es transferible. Pero es única.

// ----------------------------------------------------------------------------
// Reference counting and Ownership
//----------------------------------------------------------------------------

Cuando se toma en propiedad un objeto con conteneo de referencias no se incrementa el contador.

Esto implica que no había un propietario prévio, es decir, el objeto acaba de ser creado o el propietario aanterior transpasa la propiedad.
Por lo general, el primer puntero que se asigna despues de la creación lleva la propiedad.

//----------------------------------------------------------------------------
// La plantilla AutoPtr
// ----------------------------------------------------------------------------

Poco::AutoPtr implementa un contador de referencias de puntero inteligente smart pointer).
Poco::AutoPtr puede crear instancias de clases que implementen un contador de referencias.
Una clase que implemente un contador de referenicas debe:
-inicializarse a uno en la creación
- implementar el método void duplicate() que incrementa el contador de referenicas
- implementar el método void release() que decremenrta el contador de referenicas y cuando valga cero destruir el recurso.

// ----------------------------------------------------------------------------
// AutoPtr - construcción y asignación
//----------------------------------------------------------------------------
Cuando se contruye un AutoPtr a partir de C*, AutoPtr toma la propiedad de C y el contador de referencias no cambia.
Cuando se asigna un AutoPtr a partir de C*, AutoPtr toma la propiedad de C y el contador de referencias no cambia.
Cuando se contruye un AutoPtr a partir de otro AutoPtr, ambos AutoPtr son propietarios de C y el contador es incrementado.Cuando se asigna un AutoPtr a otro AutoPtr, ambos AutoPtr son propietarios de C y el contador es incrementado.


#include "Poco/AutoPtr.h"

using Poco::AutoPtr;

class RCO
{
public:
RCO(): _rc(1){}

void duplicate(){
++_rc; // Warning: not thread safe!
}

void release(){
if (--_rc == 0) delete this; // Warning: not thread safe!
}

private:
int _rc;
};int main(int argc, char** argv)
{
RCO* pNew = new RCO; // _rc == 1

AutoPtr p1(pNew); // _rc == 1
AutoPtr p2(p1); // _rc == 2
AutoPtr p3(pNew, true); // _rc == 3

p2 = 0; // _rc == 2
p3 = 0; // _rc == 1

RCO* pRCO = p1; // _rc == 1

p1 = 0; // _rc == 0 -> deleted
// pRCO and pNew now invalid!
p1 = new RCO; // _rc == 1

return...