Storing type information about an object with out templating the outer object or having inhertance on the parent object. Exploring some code that uses a similar method for C++ reflect system

TypeHolder.cpp

#include "cstdio"

// No type information
class ClassMeta
{
    class Holder
    {
    public:
        virtual void* GetPtr() const { return NULL; }
    protected:
        Holder() {};
        ~Holder() {};
    };

    template <typename CLASS> struct HolderBase;
    template <typename CLASS> struct HolderPtr;

    Holder* m_pHolder;
public:
    template <typename CLASS>
    ClassMeta(const CLASS& _Object);


    template <typename CLASS>
    ClassMeta(CLASS* _pObject);
};


template <typename CLASS> struct ClassMeta::HolderBase : public ClassMeta::Holder
{
};

template <typename CLASS> struct ClassMeta::HolderPtr : public ClassMeta::HolderBase<CLASS>
{
    HolderPtr(const CLASS* _pObject) : m_pObject(const_cast<CLASS*>(_pObject)) {}
    CLASS* m_pObject;
};


// Allow the holder to hold basic types
template<> struct ClassMeta::HolderBase<bool>           : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<const char>     : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<char>           : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<signed char>    : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<unsigned char>  : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<short>          : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<unsigned short> : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<int>            : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<unsigned int>   : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<long>           : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<unsigned long>  : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<float>          : public ClassMeta::Holder {};
template<> struct ClassMeta::HolderBase<double>         : public ClassMeta::Holder {};


template <typename CLASS>
ClassMeta::ClassMeta(const CLASS& _Object)
{
    m_pHolder = new HolderPtr<CLASS>(&_Object);
}


template <typename CLASS>
ClassMeta::ClassMeta(CLASS* _pObject)
{
    m_pHolder = new HolderPtr<CLASS>(_pObject);
}


struct Test
{

};

int main()
{
    Test t;
    ClassMeta* c = new ClassMeta(t);
    printf("hello world");
}