Создание объекта по имени класса

CObject* c=CRuntimeClass::FromName("MyClass").CreateObject();

class RTTIParent
{
public:
};
 
//виртуальные методы есть. Но RTTI это не поможет
class RTTIChild:public RTTIParent
{
public:
    virtual~RTTIChild(){}
};
 
int main(int argc, char *argv[])
{
    RTTIParent* pointer=new RTTIChild;
    cout<<typeid(*pointer).name()<<endl;
    return 0;
}

#include <iostream>
#include<string>
#include<typeinfo>
 
using namespace std;
 
class RTTIParent
{
public:
    virtual~RTTIParent(){}
};
 
class RTTIChild
{
public:
    virtual~RTTIChild(){}
};
 
int main(int argc, char *argv[])
{
    RTTIParent* pointer=(RTTIParent*)new RTTIChild;
    cout<<typeid(*pointer).name()<<endl;
    return 0;
}

#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <map>
 
 
 
template<class YouInterface> struct TFactory
{
    typedef ::std::string
        Str;
    typedef std::vector<Str>
        RegList;
private:
    struct Base
    {
        virtual ~Base(){}
        virtual YouInterface* Build()const=0;  
    };
 
    template<class T> struct Builder : Base
    { 
        virtual YouInterface* Build()const { return new T; };  
    };
 
    typedef std::map<Str, Base*>
        Map;
    typedef typename Map::const_iterator
        It;
    typedef typename Map::value_type
        ValType;
public:
    TFactory()
        :mData()
    {}
 
    //--- нужна, что бы удалить ассоциацию: символьное_имя <-> тип_класса
    static void Del(const char* key);
    static void Del(const Str& key);
 
    //--- нужна, что бы удалить ассоциацию: символьное_имя <-> тип_класса
    //--- В качестве символьного имени будет использовано имя объекта obj.GetName()
    template<class T> static void Del(const T& obj);
 
    //--- нужна, что бы установить ассоциацию: символьное_имя <-> тип_класса
    template<class T> static void Add(const Str&  key);
    template<class T> static void Add(const char* key);
    
    //--- нужна, что бы установить ассоциацию: символьное_имя <-> тип_класса
    //--- В качестве символьного имени будет использовано имя объекта obj.GetName()
    template<class T> static void Add(const T& obj);
 
    //--- построит объект класса по его символьному имени
    static YouInterface& Build(const Str& key);
 
    //--- вернет список всех зарегистрированных имен
    static RegList GetNames();
 
    //--- true, если указанное имя существует в банке данных
    static bool Exist(const Str&  key);
private:
    static Map& Reg();
 
    Map mData;
};
 
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
 
template<class YouInterface>  
    void TFactory<YouInterface>::Del(const char* key)
    {
        const It it = Reg().find(key);
        if( it==Reg().end() )
            return;
        delete it->second;
        Reg().erase(key);
    }
 
template<class YouInterface>  
    void TFactory<YouInterface>::Del(const Str& key)
        { Del( key.c_str() ); }
 
 
template<class YouInterface>  
    template<class T> 
        void TFactory<YouInterface>::Del(const T& obj)
            { Del(obj.GetName()); }
 
template<class YouInterface>  
    template<class T> 
        void TFactory<YouInterface>::Add(const char* key)
            { Reg().insert( ValType(key, new Builder<T>())  ); }
 
 
template<class YouInterface>  
    template<class T> 
        void TFactory<YouInterface>::Add(const Str& key)
            { Reg().insert( ValType(key, new Builder<T>())  ); }
 
template<class YouInterface>  
    template<class T>
        void TFactory<YouInterface>::Add(const T& obj)
            { Reg().insert( ValType( obj.GetName(), new Builder<T>()) ); }
 
template<class YouInterface>  
    YouInterface& TFactory<YouInterface>::Build(const Str& key)
    {
        const It it = Reg().find(key);
        const bool ERROR_KEY_NOT_EXISTS = it==Reg().end();
        assert(!ERROR_KEY_NOT_EXISTS);
        if(ERROR_KEY_NOT_EXISTS)
            throw ::std::logic_error("ERROR_KEY_NOT_EXISTS");
        return *it->second->Build() ;
    }
 
template<class YouInterface>
    typename TFactory<YouInterface>::RegList 
        TFactory<YouInterface>::GetNames()
        {
            RegList result;
            Map& bd = Reg();
            result.reserve( bd.size() );
            for(It it = bd.begin(); it!=bd.end(); ++it)
                result.push_back(it->first);
            return result;
        }
 
template<class YouInterface>
    bool TFactory<YouInterface>::Exist(const Str& key)
        { return Reg().find(key)!=Reg().end(); }
 
template<class YouInterface>
    typename TFactory<YouInterface>::Map& 
        TFactory<YouInterface>::Reg()
            { static TFactory f; return f.mData; }
 
 
struct sample
{
    virtual ~sample(){}
    virtual void view()const = 0;
};
 
struct foo: sample
{
    virtual void view()const { std::cout << "foo\n"; }
};
 
struct bar: sample
{
    virtual void view()const { std::cout << "bar\n"; }
};
 
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    using factory = TFactory<sample>;
    
    factory::Add<foo>("foo");
    factory::Add<bar>("bar");
    
    factory::Build("foo").view();
    factory::Build("bar").view();
}