Найти причины ошибок времени компиляции внутри класса, генерируемого фабричной функцией

return shared_ptr<Object>(new Constant(1, name));

vector<shared_ptr<Object>>object;
....
shared_ptr<Object> mEx = creator.createObject(8, object);

shared_ptr<Object> Creator::createObject(int id, vector<shared_ptr<Object>>str)
{
    if (id == 8)
    {
        shared_ptr<Object> obj = std::make_shared<MathExp>(1, str);
        return obj;
    }
    else if (id == 9)
    {
        shared_ptr<Object> obj = std::make_shared<JumpIf>(1, str);
        return obj;
    }
}

MathExp::MathExp(int c, vector<Object*>str)
    : Object(c), objects(str){}

class MathExp : public Object
{
public:
    MathExp(int, vector<shared_ptr<Object>>);
    
    virtual void accept(Visitor&);
 
private:
    vector<shared_ptr<Object>>objects;
    
};
 
MathExp::MathExp(int c, vector<shared_ptr<Object>>str)
    : Object(c), objects(str){}

if (id == 8)

shared_ptr<Object> Creator::createObject(int id, string name)
{
    switch (id)
    {
    case 1:
        SymbolTable::instance().addSymbol(name);
        return shared_ptr<Object>(new Constant(1, name));
        break;
    case 2:
        SymbolTable::instance().addSymbol(name);
        return shared_ptr<Object>(new Variable(1, name));
        break;
    case 3:
        return shared_ptr<Object>(new Assign(1, name));
        break;
    case 4:
        return shared_ptr<Object>(new MathOp(1, name));
        break;
    case 6:
        return shared_ptr<Object>(new Address(1, name));
        break;
    case 7:
        return shared_ptr<Object>(new LogicOp(1, name));
        break;
    }
}

 case 1:
        SymbolTable::instance().addSymbol(name);
        return shared_ptr<Object>(new Constant(1, name));
        break;

#include <iostream>
#include <map>
#include <vector>
 
//=============================================================================
enum ID { frst, scnd };
 
class Parent;
 
typedef std::map<ID, Parent*> Registry;
 
Registry& getRegistry ()
{
    static Registry regInst;
    return regInst;
}
 
//=============================================================================
class Helper {};
 
//=============================================================================
// Parent
class Parent
{
protected:
    void addPrototype (ID id, Parent* ptr)
    {
        auto& reg = getRegistry();
        reg[id] = ptr;
    }
 
public:
    static Parent* createObject (ID id)
    {
        auto& reg = getRegistry();
        if (reg.find(id) != reg.end())
            return reg[id] -> clone();
        return nullptr;
    }
 
    virtual void info () = 0;
    virtual Parent* clone () = 0;
 
    virtual ~Parent () {}
};
 
//=============================================================================
// First
class First: public Parent
{
private:
    First () {}
 
    First (Helper)
    { Parent::addPrototype(frst, this); }
 
    static First prototype;
 
public:
    void info () override
    { std::cout << "First" << std::endl; }
 
    Parent* clone () override
    { return new First(*this); }
};
 
//=============================================================================
// Second
class Second: public Parent
{
private:
    Second () {}
 
    Second (Helper)
    { Parent::addPrototype(scnd, this); }
 
    static Second prototype;
 
public:
    void info () override
    { std::cout << "Second" << std::endl; }
 
    Parent* clone () override
    { return new Second(*this); }
};
 
//=============================================================================
// static
First First::prototype = First(Helper());
Second Second::prototype = Second(Helper());
 
//=============================================================================
int main ()
{
    std::vector<Parent*> vp;
    vp.push_back(Parent::createObject(frst));
    vp.push_back(Parent::createObject(frst));
    vp.push_back(Parent::createObject(scnd));
 
    for (const auto& j : vp)
        j -> info();
 
    for (auto j : vp)
        delete j;
 
    return 0;
}

...
Parent* First::clone () override
    { return new First(*this); }
...

...
First* First::clone () override
    { return new First(*this); }
...

for (const auto& j : vp)
        j -> info();
 
for (auto j : vp)
       delete j;