Мой синглтон. Дайте рекомендации, оцените, пожалуйста

// Z:\programming\classes_cpp\general\gen_Tsingleton_pat\gen_Tsingleton_pat.h
 
#ifndef __GEN_TSINGLETON_PAT_H_
#define __GEN_TSINGLETON_PAT_H_
 
 
#include <memory>
 
 
/**
*
*/
template <class X> class gen_Tsingleton_pat
{
 
    public:     
 
        static X* instance();
 
    protected:
 
        static std::auto_ptr<X> m_obj_;
 
        gen_Tsingleton_pat();
        virtual ~gen_Tsingleton_pat();
 
    private:
 
        gen_Tsingleton_pat(const gen_Tsingleton_pat& obj);
        gen_Tsingleton_pat& operator=(const gen_Tsingleton_pat& obj);
 
};
 
 
#endif // __GEN_TSINGLETON_PAT_H_
 
 
// Z:\programming\classes_cpp\general\gen_Tsingleton_pat\gen_Tsingleton_pat.cpp
 
 
#include "Z:\programming\classes_cpp\general\gen_Tsingleton_pat\gen_Tsingleton_pat.h"
 
 
/**
*
*/
template <class X> gen_Tsingleton_pat<X>::gen_Tsingleton_pat()
{
}
 
 
/**
*
*/
template <class X> gen_Tsingleton_pat<X>::~gen_Tsingleton_pat()
{
}
 
 
/**
*
*/
template <class X> X* gen_Tsingleton_pat<X>::instance()
{
 
    if(!m_obj_)
        m_obj_ = std::auto_ptr<X>(new X);
    return m_obj_.get();
 
}

template<typename T>
struct An
{
    template<typename U>
    friend struct An;                     //!!! Что за член такой? Может, это декларация типа?
 
    An()                              {}
 
    template<typename U>           //!!! Не совсем понятно для чего тип U?
    An(const An<U>& a) : data(a.data) {}
 
    template<typename U>
    An(An<U>&& a) : data(std::move(a.data)) {}
 
    T* operator->()                   { return get0(); }
    const T* operator->() const       { return get0(); }
    bool isEmpty() const              { return !data; }
    void clear()                      { data.reset(); }
    void init()                       { if (!data) reinit(); }
    void reinit()                     { anFill(*this); }
    
    T& create()                       { return create<T>(); }
 
    template<typename U>
    U& create()                       { U* u = new U; data.reset(u); return *u; }
    
    template<typename U>
    void produce(U&& u)               { anProduce(*this, u); }
 
    template<typename U>
    void copy(const An<U>& a)         { data.reset(new U(*a.data)); }
 
private:
    T* get0() const
    {
        const_cast<An*>(this)->init();
        return data.get();
    }
 
    std::shared_ptr<T> data;
};

    template<typename U>
    An(const An<U>& a) : data(a.data) {}

    template<typename U>
    An(An<U>&& a) : data(std::move(a.data)) {}

template<typename U>
    An(An<U>&& a) : data(std::move(a.data)) {}

MyClass* ptr=Tsingleton<MyClass>::getInstance();
MyClass* ptr=new MyClass;

    void reinit() { anFill(*this); } //!!! anFill - это параметризованная функция, определяет тип по типу параметра?
 
    // А тут как быть? две функции почти одинаковы, не будет неоднозначности при вызове?
 
    T& create()                       { return create<T>(); }
 
    template<typename U>
    U& create()                       { U* u = new U; data.reset(u); return *u; }

void reinit()                     { anFill(*this); // - anFill шаблонная. }

// Файл "Z:\programming\classes_cpp\general\gen_Tsi_pat\gen_Tsi_pat.h"
 
#ifndef __GEN_TSI_PAT_H_
#define __GEN_TSI_PAT_H_
 
#define PROTO_IFACE(D_iface, D_an)    \
    template<> void anFill<D_iface>(An<D_iface>& D_an)
 
#define DECLARE_IMPL(D_iface)    \
    PROTO_IFACE(D_iface, a);
 
#define BIND_TO_IMPL(D_iface, D_impl)    \
    PROTO_IFACE(D_iface, a) { a.create<D_impl>(); }
 
#define BIND_TO_SELF(D_impl)    \
    BIND_TO_IMPL(D_impl, D_impl)
 
#define BIND_TO_IMPL_SINGLE(D_iface, D_impl)    \
    PROTO_IFACE(D_iface, a) { a = anSingle<D_impl>(); }
 
#define BIND_TO_SELF_SINGLE(D_impl)    \
    BIND_TO_IMPL_SINGLE(D_impl, D_impl)
 
#define BIND_TO_IFACE(D_iface, D_ifaceFrom)    \
    PROTO_IFACE(D_iface, a) { anFill<D_ifaceFrom>(a); }
 
#define BIND_TO_PROTOTYPE(D_iface, D_prototype)    \
    PROTO_IFACE(D_iface, a) { a.copy(anSingle<D_prototype>()); }
 
#include <memory>
#include <string>
 
 
 
template<typename T>
struct An
{
    template<typename U>
    friend struct An;
 
    An()                              {}
 
    template<typename U>
    An(const An<U>& a) : data(a.data) {}
 
    template<typename U>
    An(An<U>&& a) : data(std::move(a.data)) {}
 
    T* operator->()                   { return get0(); }
    const T* operator->() const       { return get0(); }
    bool isEmpty() const              { return !data; }
    void clear()                      { data.reset(); }
    void init()                       { if (!data) reinit(); }
    void reinit()                     { anFill(*this); }
    
    T& create()                       { return create<T>(); }
 
    template<typename U>
    U& create()                       { U* u = new U; data.reset(u); return *u; }
    
    template<typename U>
    void produce(U&& u)               { anProduce(*this, u); }
 
    template<typename U>
    void copy(const An<U>& a)         { data.reset(new U(*a.data)); }
 
private:
    T* get0() const
    {
        const_cast<An*>(this)->init();
        return data.get();
    }
 
    std::shared_ptr<T> data;
};
 
 
template<typename T>
struct AnAutoCreate : An<T>
{
    AnAutoCreate()     { create(); }
};
 
template<typename T>
T& single()
{
    static T t;
    return t;
}
 
template<typename T>
An<T> anSingle()
{
    return single<AnAutoCreate<T>>();
}
 
 
template<typename T>
void anFill(An<T>& a)
{
    throw std::runtime_error(std::string("Cannot find implementation for interface: ")
            + typeid(T).name());
}
 
#endif // __GEN_TSI_PAT_H_

// h
 
#include "Z:\programming\classes_cpp\general\gen_Tsi_pat\gen_Tsi_pat.h"
 
 
struct X
{
    X()            { x = 1; }
    
    int x;
};
 
// декларация заливки реализации
DECLARE_IMPL(X)
 
int init();
 
// cpp
 
struct Y : X
{
    Y()            { x = 2; }
        
    int y;
};
 
// связывание декларации X и реализации Y используя синглтон
BIND_TO_IMPL_SINGLE(X, Y)
 
 
int init()
{
 
    An<X> x;    
    return x->x;             //!!! Возврящает 1, а в статье говорится, что вернул 2. 
 
}