Обойтись без наследования

class Screen
{
 private:
    bool active = false;
 
  public:
    void activate()
    {
      if(active)
        return;
 
      active = true; 
      onActivate();
    }
 
  protected:
    virtual void onActivate() {}
}

class ScreenMainmenu : public Screen
{
  protected:
    void onActivate() override {// реализация метода при загрузке/первом показе экрана}
}

// подобие trait в Rust
// здесь нельзя иметь поля
struct Screen
{
    virtual void onActivate() = 0;
}
 
struct ScreenMainmenu : public Screen
{
    void onActivate() override
    {
        // реализация 
    }
}
 
struct ScreenManager
{
    bool active[NUM_SCREENS]; // флаги на все экраны
    Screen* screens[NUM_SCREENS]; // указатели на все экраны
    
    void activate(EScreen screenID)
    {
        if(active[screenID])
            return;
        
        active[screenID] = true;
        screens[screenID].onActivate();
    }
}

// Делаем вообще один класс для всего
struct Screen
{
    bool active = false;
    
    void activate()
    {
        if(active)
            return;
        
        active = true;
        
        if(onActivate)
            onActivate();
    }
    
    std::func<void(Screen*)> onActivate = nullptr;
}
 
// Создаем реализацию
 
void ScreenMainMenu_OnActivate(Screen* THIS)
{
    // реализация
}
 
Screen screenMainmenu;
screenMainmenu.onActivate = ScreenMainMenu_OnActivate;

trait Activator {
    fn activate_with<F: FnOnce()>(&mut self, activation: F);
}
 
impl Activator for bool {
    fn activate_with<F: FnOnce()>(&mut self, activation: F) {
        if !*self {
            *self = true;
            activation();
        }
    }
}
 
fn main() {
    let mut active = false;
    active.activate_with(|| println!("Activating"));
}

bool::activate_with(std::function func){
  if(!*this)
    *this = true;
     
    func();
}

struct ActivatorTrait
{
    virtual void activate(std::function f) = 0;
}
 
struct Activator : public ActivatorTrait
{
    bool active = false;
    
    void activate(std::function f) override
    {
        if(active)
            return;
        
        active = true;
        
        f();
    }
}
 
struct Screen
{   
    virtual void activate();
}
 
struct ScreenMainmenu : public Screen
{
    Activator activator;
    
    // в таких местах снова для каждого экрана нужно будет копировать код ) 
    // хоть меньше но придется
    void activate() override
    {
        activator.activate([this]{this->onActivate});
    }
    
    void onActivate()
    {
        
    }
}

[this]{this->onActivate();}

struct ActivatorTrait
{
    // дефолтная реализация для переиспользования кода
    virtual void activateWithFlag(bool& flag)
    {
        if(flag)
            return;
        
        flag = true;
        onActivate();
    }
    
        // метод для пользователя
    virtual void activate() = 0;
    
    virtual void onActivate() = 0;
}
 
struct Screen
{
    bool active = false;
}
 
struct ScreenMainmenu : public ActivatorTrait
{
        // композиция
    Screen screen;
    
    void activate() override
    {
        // переиспользуем код
        activateWithFlag(screen.active);
    }
    
    void onActivate() override
    {
        
    }
}

struct screen_activator {
    void activate() const noexcept {
        te::call([](auto const& self) { self.activate(); }, *this);
    }
};
 
struct fullhd_screen {
  void activate() const noexcept { std::cout << "fullhd_screen\n"; }
};
 
struct lowhd_screen {
  void activate() const noexcept { std::cout << "lowhd_screen\n"; }
};
 
void activate(te::polymorphic<screen_activator> const &a) { a.activate(); }
 
int main() {
    activate(fullhd_screen{});
    activate(lowhd_screen{});
}