Suppose we have the following class hierarchy:
class Object {
public:
virtual void update() {
// Update position
}
};
class Rocket : public Object {
public:
virtual void update() {
Object::update();
// Orientate towards target
}
};
class SparklingRocket : public Rocket {
public:
virtual void update() {
Rocket::update();
// Create sparkling particles
}
};
For obvious reason this is no good idea. For instance an inheritor of any of the classes might forget to call Base::update() and the behaviour of the program would be incomplete. As I see it, functions that implement important behaviour shouldn't be made virtual, that's something better reserved for replaceable behaviour.
So, we would probably change the architecture like that:
class Object {
public:
void update() {
// Update position
afterObjectUpdate();
}
protected:
virtual void afterObjectUpdate() {}
};
class Rocket : public Object {
protected:
virtual final void afterObjectUpdate() override {
// Orientate towards target
afterRocketUpdate()
}
virtual void afterRocketUpdate() {}
};
class SparklingRocket : public Rocket {
protected:
virtual final void afterRocketUpdate() {
// Create sparkling particles
afterSparklingRocketUpdate();
}
virtual void afterSparklingRocketUpdate() {}
};
This is pretty much what I want:
- The public interface of all classes is only the non-virtual update() - method
- When that method is called it is ensured that every update()-"submethod" is called
- Even if the one inheritor forgets to call a afterUpdate() - method, the hierarchy is stable from the base class down. This way a API could ensure its own integrity whilst in the first codeexample it would have to rely on the user to call the Base::update() method
I dislike one thing though: The name of each class is part of the after...Update() methodname. That seems like codesmell to me.
I think the general goal of keeping virtual call hierarchies stable can't be that uncommon. What is the commonly applied solution that I didn't come across yet?
