Classe smart pointer maison

Bonjour,
Jusque là j'utilise boost::shared_ptr, toujours de cette manière:

class A;
typedef boost::shared_ptr<A> APtr;

class A
{
public:
static APtr New()
{
return APtr( new A );
}

protected:
A() {}

// ...
};

APtr a = A::New();
// ...

Mais c'est un peu lourd à écrire à chaque fois. J'essaye de capitaliser
tout ça dans une classe smart ptr template à moi, qui s'utiliserait ainsi:

class A : PtrBase<A>
{
// ...
};

A::ptr a = A::New();

A ce sujet je suis étonné de ne pas trouver de classe smart ptr qui
utilise une base dont il faut hériter. Celà règle le problème de loger
quelque part le compteur partagé. Enfin, à mon avis.

Donc PtrBase contient la gestion du compteur, et définit le type ptr. Ca
ressemble à ça:

// déclaration de la classe smart pointeur
template<typename T>
class Ptr;

// la classe dont on hérite et qui sert à stocker
// le compteur
template<typename T>
class PtrBase
{
public:
typedef Ptr<T> ptr;

static Ptr<T> New()
{
return new T;
}

template<typename P1>
static Ptr<T> New( P1 p1 )
{
return new T( p1 );
}


protected:
PtrBase() : count( 0 ) {}
virtual ~PtrBase() {}

private:
// donner accès à la classe smart ptr pour qu'elle
// gère le compteur
friend class Ptr<T>;
int count;
};

// implémentation de la classe smart pointeur
template<typename T>
class Ptr
{
public:
Ptr() : ptr( 0 ) {}

Ptr( T * t ) :
ptr( t )
{
++this->ptr->count;
}

Ptr( const Ptr<T> & p ) :
ptr( p.ptr )
{
++this->ptr->count;
}

~Ptr()
{
if ( this->ptr &&
--this->ptr->count == 0 )
{
delete this->ptr;
}
}

T * operator ->()
{
assert( this->ptr );
return this->ptr;
}

void reset()
{
if ( this->ptr )
{
--this->ptr->count;
this->ptr = 0;
}
}

private:
T *ptr;
};

Exemple d'utilisation:

class A : public PtrBase<A>
{
protected:
friend PtrBase<A>; // nécessaire...

A( int )
{
cout << "A::A()\n";
}

public:
~A()
{
cout << "A::~A()\n";
}

public:
int value;
};

int main()
{
A::ptr a1 = A::New( 10 );
A::ptr a2 = a1;
a1->value = 0;
a1.reset();
cout << a2->value << '\n';
}

Qu'en pensez-vous ? Voyez-vous mieux ?
Celà existe-t-il déjà ?

Merci.

--
Aurélien Regat-Barrel