Pour étayer ma réponse, je dirais qu'on voit ici un élément intéressant de la programmation orientée objet qui simplifie beaucoup de problèmes : le polymorphisme.

Tu auras peut être remarqué que mon objet a une relation d'héritage sur EventHandler, une interface fictive qu'on pourrait définir ainsi :

class EventHandler {
public:
    virtual void notifyEvent(Engine::Event *event) = 0;
    virtual void updateFrame(float deltaT) = 0;
};

Ca signifie que toute classe héritant de EventHandler, s'engage à fournir une implémentation pour répondre à ces deux méthodes. En d'autres termes, si on se trimballe un sous-type de EventHandler, on a forcément un objet qui répond à ces deux méthodes. L'idée c'est donc d'avoir une liste d'EventHandler, dont on ne connait pas la classe réelle (ça peut être un haut fait ou un autre, voire encore autre chose) mais on s'en fiche : on sait juste qu'on peut leur notifier des événements et qu'elles en feront ce que bon leur semble.

Voilà alors comment on pourrait implémenter ça dans le jeu :

extern std::vector<EventHandler*> frameUpdateObservers;

int main(void) {
    // Boucle du jeu
    while (true) {
        // ... (dessin, etc.)

        // Notifie la fin de frame à ceux qui sont enregistrés
        for (unsigned i = 0; i < frameUpdateObservers.size(); i++) {
            // On a des EventHandler, donc ils répondent à updateFrame(float)
            frameUpdateObservers[i]->updateFrame(0.016666f);
        }
    }
    return 0;
}

Et pour enregistrer des objets, aussi simple :

std::vector<EventHandler*> frameUpdateObservers;

void registerForUpdate(EventHandler *observer) {
    frameUpdateObservers.push_back(observer);
}

Avec cette syntaxe, on force quiconque veut enregistrer un objet (registerForUpdate) à fournir un sous-type de EventHandler, donc un objet sachant au moins gérer un appel à updateFrame(float). On pourra donc le faire en toute sécurité.