How to implement a static factory pattern?

See more:

C++

Factory

I tried to implement a templated factory pattern but could not get it to work. Not sure if this was because I used smart pointers.

This is my code:

class ObjMgr
{
public:
    static ObjMgr & Instance();
    template <typename T>
    void Register(const char* name) {
        m_creators[name] = &(ObjCreator<T>);
    }
    Abstract &
        GetObj(const string& objTypeCode);

private:
    ObjMgr(void) {};

    template <typename T>
    static shared_ptr<Abstract>& ObjCreator() {
        return move(std::shared_ptr<Abstract> (new T));
    }
    typedef shared_ptr<Abstract>& (*PObjCreator)();
    std::unordered_map<std::string, PObjCreator> m_creators;

    vector< shared_ptr<Abstract> > m_objs;

    //singleton
    static unique_ptr<ObjMgr> m_instance;
    static std::once_flag m_onceFlag;
    ObjMgr(const ObjMgr &) = default;
    ObjMgr& operator=(const ObjMgr &) = default;
};

Abstract& ObjMgr::GetObj(const string& objTypeCode)
{
    const shared_ptr<Abstract>& obj = m_creators[objTypeCode]();
    m_objs.push_back(move(obj));

    return *(m_objs.back());
}

The code compiles but at runtime, a null reference was returned by GetObj.

In main(), a derived type is registered as

objMgr.Register<Derived>("Derived");

BTW, I used a vector to hold the objects so that I could later recycle the object of the same type.
Could someone tell me what I did wrong and show me how I could correct it?