Composition over inheritance

Inheritance An example in C++ follows: • include • include • include class GameObject { public: virtual void update() { // no-op } virtual void draw() const { // no-op } virtual void collide(vector objects) { // no-op } }; class Visible : public GameObject { private: std::unique_ptr model; public: virtual void draw() const override { // code to draw a model at the position of this object } }; class Solid : public GameObject { public: virtual void collide(std::vector objects) override { // code to check for and react to collisions with other objects } }; class Movable : public GameObject { public: virtual void update() override { // code to update the position of this object } }; Then, suppose we also have these concrete classes: • class - which is , and • class - which is and , but not • class - which is and , but not • class - which is , but neither nor Note that multiple inheritance is dangerous if not implemented carefully because it can lead to the diamond problem. One solution to this is to create classes such as , , , etc. for every needed combination; however, this leads to a large amount of repetitive code. C++ uses virtual inheritance to solve the diamond problem of multiple inheritance. Composition and interfaces The C++ examples in this section demonstrate the principle of using composition and interfaces to achieve code reuse and polymorphism. Due to the C++ language not having a dedicated keyword to declare interfaces, the following C++ example uses inheritance from a pure abstract base class. For most purposes, this is functionally equivalent to the interfaces provided in other languages, such as Java and C#. Introduce an abstract class named , with the subclasses and , which provides a means of drawing an object: class VisibilityDelegate { public: virtual void draw() const = 0; }; class NotVisible : public VisibilityDelegate { public: virtual void draw() const override { // no-op } }; class Visible : public VisibilityDelegate { public: virtual void draw() const override { // code to draw a model at the position of this object } }; Introduce an abstract class named , with the subclasses and , which provides a means of moving an object: class UpdateDelegate { public: virtual void update() = 0; }; class NotMovable : public UpdateDelegate { public: virtual void update() override { // no-op } }; class Movable : public UpdateDelegate { public: virtual void update() override { // code to update the position of this object } }; Introduce an abstract class named , with the subclasses and , which provides a means of colliding with an object: import std; using std::vector; class CollisionDelegate { public: virtual void collide(vector objects) = 0; }; class NotSolid : public CollisionDelegate { public: virtual void collide(vector objects) override { // no-op } }; class Solid : public CollisionDelegate { public: virtual void collide(vector objects) override { // code to check for and react to collisions with other objects } }; Finally, introduce a class named with members to control its visibility (using a ), movability (using an ), and solidity (using a ). This class has methods which delegate to its members, e.g. simply calls a method on the : import std; using std::unique_ptr; using std::vector; class GameObject { private: unique_ptr visibilityDelegate; unique_ptr updateDelegate; unique_ptr collisionDelegate; public: GameObject(VisibilityDelegate* v, UpdateDelegate* u, CollisionDelegate* c): visibilityDelegate{std::make_unique(v)}, updateDelegate{std::make_unique(u)}, collisionDelegate{std::make_unique(c)} {} void update() { updateDelegate->update(); } void draw() const { visibilityDelegate->draw(); } void collide(vector objects) { collisionDelegate->collide(objects); } }; Then, concrete classes would look like: class Player : public GameObject { public: Player(): GameObject(new Visible(), new Movable(), new Solid()) {} // ... }; class Smoke : public GameObject { public: Smoke(): GameObject(new Visible(), new Movable(), new NotSolid()) {} // ... }; ==Benefits==