Синглтон и время жизни объекта

#include "stdafx.h"
 
#include <iostream>
#include <memory>
 
// Loki::CreateUsingNew with abstract classes support.
template< class T, class I = T >
struct CreateUsingNew
{
    static I* Create(){ return new T; }        
    static void Destroy( I* p ){ delete static_cast< T * >( p ); }
};
 
// Use CreateUsingNew< T > as the default creation strategy.
template< class T >
struct SelectCreationStrategy
    : CreateUsingNew< T >
{
};
 
template< class T, template< class > class TCreationStrategy = SelectCreationStrategy >
class An
{
    std::shared_ptr< T > _guard;
 
    T &get()
    {
        static std::shared_ptr< T > p( TCreationStrategy< T >::Create(), &TCreationStrategy< T >::Destroy );
 
        _guard = p;
 
        return *p;
    }
 
public:
 
    T &operator*(){ return get(); }
    T *operator->(){ return &get(); }
};
 
// Note: usage of this singleton is the same as in the previous variate, no macro, etc.
struct A
{
    A(){ std::cout << "A" << std::endl; a = 1; }
    ~A(){ std::cout << "~A" << std::endl; a = -1; }
 
    int a;
};
 
// Abstract
struct B 
{
    B(){ std::cout << "B" << std::endl; }
    ~B(){ std::cout << "~B" << std::endl; }
 
    virtual void out() = 0;
};
 
// Impl
struct C : B
{
    An< A > pa;
 
    C(){ std::cout << "C" << std::endl; }
    ~C(){ std::cout << "~C" << std::endl; out(); }
 
    virtual void out(){ std::cout << pa->a << std::endl; }
};
 
// Overridden creation strategy for B.
// Note: you can use even custom allocators here.
template<>
struct SelectCreationStrategy< B >
    : CreateUsingNew< C, B >
{
};
 
int _tmain( int, _TCHAR*[] )
{
    An< B > pb;
    pb->out();
 
    return 0;
}