В зависимости от выбора пользователя, инициализировать один из классов-наследников и использовать только его

//-------------------------------------------------------------------------        
//---------- кросс-платформенный макрос отображения имени функции ---------
//-------------------------------------------------------------------------        
 
#if defined(__GNUC__) || defined(__MINGW32__) || defined(__MINGW__)
    #define dFUNCTION __PRETTY_FUNCTION__
#else
    #ifdef _MSC_VER
        #define dFUNCTION __FUNCSIG__
    #else
        #define dFUNCTION __FUNCTION__
    #endif
#endif
 
//-------------------------------------------------------------------------         
//-------------------------------------------------------------------------        
//-------------------------------------------------------------------------       
 
#include <unordered_map>
 
// фабрика позволяет создавать наследника
// по символьному имени класса
 
struct ibase;
 
class factory
{
    typedef ibase* (*creator)();
    typedef std::unordered_map<std::string, creator> 
        creators;
 
    static creators& data() 
    {
        static creators data;
        return data;
    }
 
    template<typename T> static ibase* create()
        { return new T; }
public:
    template<typename T>
    static void reg( const std::string& name )
    {
        auto& c = data();
        if( c.cend() == c.find(name) )
            c.emplace( name, &create<T>);
    }
 
    static ibase* create( const std::string& name ) 
    {
        auto& c = data();
        auto it = c.find( name );
        if( c.cend() != it )
            return (it->second)();
        return nullptr;
    }
};
#define REGISTER(cl) factory::reg<cl>( #cl )
 
 
//-------------------------------------------------------------------------         
//-------------------------------------------------------------------------        
//-------------------------------------------------------------------------       
 
 
// теперь определяем базовый интерфейс будущих наследников
struct ibase{
    
    virtual ~ibase(){}
    
    // все эти методы должны будут реализовать наследники
    virtual void init()=0;
    virtual void update()=0;
    virtual void draw()=0;
};
 
//-------------------------------------------------------------------------         
//-------------------------------------------------------------------------        
//-------------------------------------------------------------------------       
 
#include <iostream>
 
// теперь создаем самих наследников
// их может быть 100500
 
#define dFIX std::cout << dFUNCTION << std::endl;
 
class directx : public ibase
{
    virtual void init()   { dFIX; }
    virtual void update() { dFIX; }
    virtual void draw()   { dFIX; }
};
 
class opengl : public ibase
{
    virtual void init()   { dFIX; }
    virtual void update() { dFIX; }
    virtual void draw()   { dFIX; }
};
 
 
struct engine
{
    engine()
    {
        // теперь нужно зарегистрировать всех наследников
        // которые могут быть использованы в работе
        REGISTER(directx);
        REGISTER(opengl);
    }
    
    
    ~engine() { delete device; }
    
    void select(const std::string& name)
    {
        device = factory::create(name);
    }
    
    
    int work()
    {
        dFIX;
        
        if(!device)
            return std::cout<<"error: device not ready\n", 1;
        
        device->init();
        device->update();
        device->draw();
        return 0;
    }
    
private:
    
    ibase* device = nullptr;
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    std::cout << "input device (directx/opengl):\n";
    std::string name = "directx";
    //std::cin >> name; 
    
    
    engine eng;
    eng.select(name);
    eng.work();
    
}

class Main
{
    /*
    ...
    */
    virtual bool Initialize();
 
    virtual void Ability1();
    virtual void Ability2();
    
    virtual void Cast();
 
protected:
    bool InitBase();
     /*
    ...
    */
};
 
class Mage : public Main
{
    /*
    ...
    */
    bool Initialize() { InitBase(); InitMage(); return true; }
 
    void Ability1();
    void Ability2();
    
    void Cast();
 
private:
    bool InitMage();
     /*
    ...
    */
};
 
 
int main()
{
    Main *Champion = new Mage;
    
    Champion->Initialize();
 
    Champion->Ability1();
    Champion->Cast();
 
}

using creator = ibase* (*)();
using crators = std::unordered_map<std::string, creator>;