Создать екземпляр из абстрактного класса

class Base
{
public:
    virtual void f() = 0;
};
 
class Child : public Base
{
public:
    void f() override
    {
 
    }
};
 
void func(const Base& base)
{
    Base* b = new Base(&base); // ошибка
}
 
int main(int argc, char* argv[])
{
    Child c;
    Base *b = &c;
    func(*b);
    return 0;
}

void func(const Base& base)
{
    Base* b = new Child(base); //Нафига такое вообще может понадобиться???
 
}
 
//Наверное, нужно вот так
Base *func(const Base& base)
{
    return new Child(base);
}

class MyConteiner
{
    std::list<Base*> bases;
public:
 
    void addObject(Base *base)
    {
        bases.push_back(new Base(*base)); // вот тут
    }
};

class Base
{
public:
    virtual void f() = 0;
    virtual Base *Copy() = 0;
};
 
class Child: public Base
{
public:
    void f() override
    {
    }
 
    virtual Base *Copy() override
    {
        return new Child();
    }
};
 
void func(const Base& base)
{
    Base* b = base.Copy();
}

int main(int argc, char* argv[])
{
    Child c;
    Base *b = &c;
    func(b);//не разыменовывайте!
    return 0;
}

func(*b); // не только можно, но и нужно

#include <iostream>
using namespace std;
 
class Base
{
public:
    virtual void f() = 0;
};
 
class Child : public Base
{
public:
    int m_data;
    Child(int data=0):m_data(data){}
    void f() override
    {
 
    }
};
 
 Base *func(Base& base)
{
 
   new (&base) Child(345);
}
 
int main(int argc, char* argv[])
{
    Child c(123);
    cout<<c.m_data<<endl;
    Base *b = &c;
    func(*b);
    cout<<((Child*)b)->m_data<<endl;
    return 0;
}

static_cast<Child*>(&s)->Iam(); // I am base

void func(Base& base)
{ 
   new (&base) Child(345);
}

#include <iostream>
 
class Base
{
public:
    virtual ~Base(){} // <--- обязательно должен быть
    
    virtual void Iam() const { std::cout << "I am base\n"; }
    virtual Base* clone() const  = 0;
};
 
class Child : public Base
{
public:
    void Iam() const override { std::cout << "I am child\n"; }
    virtual Base* clone() const override { return new Child; }
};
 
void work(const Base& b)
{
    b.Iam();
}
 
void func(const Base& b)
{
    Base* s = b.clone();
 
    work(b);
    work(*s); // <--- work ожидает, что ей передадут реальный объект
    // --- поэтому разыменовываем указатель
    
    delete s;
}
 
int main(int argc, char* argv[])
{
    (void) argc;
    (void) argv;
    
    Child c;
    func(c);
}