struct Creature
{
  string name;
  int attack, defense;
  // Constructor, operator...
};

class CreatureModifier
{
  CreatureModifier* next{nullptr};
protected:
  Creature& creture; // reference, pointer or shared_ptr
public:
  explicit CreatureModifier(Creature& creature)
    : creature(creture) {}

  void add(CreatureModifier* cm)
  {
    if (next) next->add(cm);
    else next =cm;
  }

  virtual void handle()
  {
    if (next) next->handle();
  }
};

class DoubleAttackModifier : public CreatureModifier
{
public:
  explicit DoubleAttackModifier(Creature& creature)
    : CreatureModifier(creature) {}

  void handle() override
  {
    creature.attack *= 2;
    CreatureModifier::handle();
  }
};

class NoBonusesModifier : public CreatureModifier
{
public:
  explicit NoBonusesModifer(Creature& creature)
    : CreatureModifier(creature) {}

  void handle() override
  {
    // Do Nothing
  }
};

struct Game
{
  signal<void(Query&)> queries; // Boost.Signals2
};

struct Query
{
  string creature_name;
  enum Argumnet { attack, defense } argument;
  int result;
};

class Creature
{
  Game& game;
  int attack, defense;
public:
  string name;
  Creature(Game& game, ...) : game{game}, ... { ... }
  // Other Members
};

int Creature::get_attack() const
{
  Query q{ name, Query::Argument::attack, attack };
  game.queries(q);
  return q.result;
}

class CreatureModifier
{
  Game& game;
  Creature& creature;
public:
  CreatureModifier(Game& game, Creature& creature)
    : game(game), creature(creature) {}
};

class DoubleAttackModifier : public CreatureModifier
{
  connection conn;
public:
  DoubleAttackModifier(Game& game, Creature& creature)
    : CreatureModifier(game, creature)
  {
    conn = game.queries.connect([&](Query& q) {
      if (q.creature_name == creature.name &&
        q.argument == Query::Argument::attack)
        q.result *= 2;
    })
  }

  ~DoubleAttackModifier() { conn.disconnect(); }
}