{"id":429,"date":"2021-01-26T11:24:28","date_gmt":"2021-01-26T11:24:28","guid":{"rendered":"https:\/\/tbekk.com\/devstream\/?p=429"},"modified":"2021-02-02T10:42:19","modified_gmt":"2021-02-02T10:42:19","slug":"write-a-c-class-that-iterates-over-its-base-classes","status":"publish","type":"post","link":"https:\/\/tbekk.com\/devstream\/blog\/2021\/01\/26\/write-a-c-class-that-iterates-over-its-base-classes\/","title":{"rendered":"Write a C++ class that iterates over its base classes?"},"content":{"rendered":"\n

Here is an interesting article showing how you can use modern C++ features (C++17 and C++20) for automating the call of functions shared by base classes. <\/em><\/p>\n\n\n\n

Tested on Compiler Explorer (https:\/\/godbolt.org\/<\/a>)<\/em> using the following options [-std=c++20 -O2 -Wall -pedantic -pthread]<\/strong><\/em><\/p>\n\n\n\n

\n\n\n\n

Suppose you have a class with multiple base classes, and you want to invoke a method on all of the base classes.<\/p>\n\n\n\n

For example, say we have Pillow<\/code> and Radio<\/code> classes:<\/p>\n\n\n\n

class Pillow\n{\npublic:\n    int price();\n    int weight();\n    void refurbish(int level);\n};\n\nclass Radio\n{\npublic:\n    int price();\n    int weight();\n    void refurbish(int level);\n};\n<\/pre>\n\n\n\n
And you want to create a PillowRadio<\/code>, which is a combination pillow and radio. It is basically a pillow and a radio glued together. Okay, this is kind of ridiculous because there is no such thing as a pillow-radio,\u00b9 but let\u2019s go along with it.<\/p>\n\n\n\n
We would like the PillowRadio class to go something like this, assuming there were some way to iterate over the base classes, for which I have made up some hypothetical syntax.<\/p>\n\n\n\n
class PillowRadio : public Pillow, public Radio\n{\npublic:\n    int price()\n    {\n        int total = 0;\n        for (typename T : base_classes_of(this)) {\n            total += T::price();\n        }\n        return total + 10; \/* extra 10 for packaging *\/\n    }\n\n    int weight()\n    {\n        int total = 0;\n        for (typename T : base_classes_of(this)) {\n            total += T::weight();\n        }\n        return total + 5; \/* extra 5 for packaging *\/\n    }\n\n    void refurbish(int level)\n    {\n        for (typename T : base_classes_of(this)) {\n            T::refurbish(level);\n        }\n    }\n};\n<\/pre>\n\n\n\n
The point is that you may have cases where you want to iterate over your base classes and aggregate the results.<\/p>\n\n\n\n
So how do you do this?<\/p>\n\n\n\n
C++ doesn\u2019t provide this degree of reflection but you can simulate it by introducing a helper class.<\/p>\n\n\n\n
template<typename... bases>\nstruct Aggregator : bases...\n{\n    int price()\n    {\n        return (0 + ... + bases::price());\n    }\n\n    int weight()\n    {\n        return (0 + ... + bases::weight());\n    }\n\n    void refurbish(int level)\n    {\n        (bases::refurbish(level), ...);\n    }\n};\n\nclass PillowRadio : Aggregator<Pillow, Radio>\n{\npublic:\n    int price()\n    {\n        return Aggregator::price() + 10; \/* extra 10 for packaging *\/\n    }\n\n    int weight()\n    {\n        return Aggregator::weight() + 5; \/* extra 5 for packaging *\/\n    }\n\n    \/* inherit refurbish from Aggregator *\/\n};\n<\/pre>\n\n\n\n
How does this work?<\/p>\n\n\n\n
The Aggregator<\/code> class is given a list of base classes, and it dutifully derives from them. So that solves the first problem: Deriving from an Aggregator<\/code> causes you to derive from all of the specified base classes.<\/p>\n\n\n\n
The methods on Aggregator<\/code> use fold expressions<\/a> which iterate over the template type parameters and combine the results in some way.<\/p>\n\n\n\n
For the case of refurbish<\/code>, we don\u2019t actually have any results to combine; we just want to invoke refurbish<\/code> on each base class, so we use the comma operator to throw the results away after invoking each method. Fortunately, refurbish<\/code> returns void<\/code>, so we don\u2019t have to worry about somebody doing a sneaky overload of the comma operator<\/a>.<\/p>\n\n\n\n
Of course, this Aggregator<\/code> is tightly coupled to the methods of its base classes. Maybe we can generalize it.<\/p>\n\n\n\n
template<typename... bases>\nstruct Aggregator : bases...\n{\n    template<typename Visitor>\n    void for_each_base(Visitor&& visitor)\n    {\n        (void(visitor(static_cast<bases&>(*this))), ...);\n    }\n};\n<\/pre>\n\n\n\n
The for_each_base<\/code> method takes a visitor functor and calls it once for each base class. We cast the result to void<\/code> so that we can safely use the comma fold operator<\/a> to throw the results away after each call of the visitor.<\/p>\n\n\n\n
Now we can implement the aggregator methods for our PillowRadio<\/code> class.<\/p>\n\n\n\n
class PillowRadio : Aggregator<Pillow, Radio>\n{\npublic:\n    int price()\n    {\n        int total = 10; \/* extra 10 for packaging *\/\n        for_each_base([&](auto&& base) { total += base.price(); });\n        return total;\n    }\n\n    int weight()\n    {\n        int total = 5; \/* extra 5 for packaging *\/\n        for_each_base([&](auto&& base) { total += base.weight(); });\n        return total;\n    }\n\n    void refurbish(int level)\n    {\n        for_each_base([&](auto&& base) { base.refurbish(level); });\n    }\n};\n<\/pre>\n\n\n\n
Okay, but what about static members?<\/p>\n\n\n\n
Since function parameters cannot be types, we have to encode the type in the parameter somehow, say by passing a suitably-cast null pointer.<\/p>\n\n\n\n
template<typename... bases>\nstruct Aggregator : bases...\n{\n    template<typename Visitor>\n    void for_each_base(Visitor&& visitor)\n    {\n        (void(visitor(static_cast<bases&>(*this))), ...);\n    }\n\n    template<typename Visitor>\n    static void static_for_each_base(Visitor&& visitor)\n    {\n        (void(visitor(static_cast<bases*>(nullptr))), ...);\n    }\n};\n<\/pre>\n\n\n\n
This time, the lambda gets a null pointer of the appropriate type. You can then access static members via that strongly-typed null pointer.<\/p>\n\n\n\n
class Pillow\n{\npublic:\n    static int list_price();\n};\n\nclass Radio\n{\npublic:\n    static int list_price();\n};\n\nclass PillowRadio : Aggregator<Pillow, Radio>\n{\npublic:\n    static int list_price()\n    {\n        int total = 10; \/* extra 10 for packaging *\/\n        static_for_each_base([&](auto* base) {\n            using Base = std::decay_t<decltype(*base)>;\n            total += Base::list_price();\n        });\n        return total;\n    }\n};\n<\/pre>\n\n\n\n
Even though the visitor is given a pointer, that pointer is always null. It is useful only for its type information, not for its value.<\/p>\n\n\n\n
It is somewhat unclear<\/a> whether it is permissible to access static members via a strongly-typed null pointer, so this alternative seems somewhat risky:<\/p>\n\n\n\n
        \/\/ dereferencing null pointer to access static member - unclear legality\n        static_for_each_base([&](auto* base) { total += base->list_price(); });\n<\/pre>\n\n\n\n
C++20 adds the ability to name the deduced template types of a lambda, so this becomes slightly less awkward:<\/p>\n\n\n\n
        static_for_each_base([&]<typename Base>(Base*) { total += Base::list_price(); });\n<\/pre>\n\n\n\n
You might want the static and nonstatic versions of for_each_base<\/code> to agree on the type of the parameter passed to the visitor, in which case you can have the nonstatic version also pass a pointer:<\/p>\n\n\n\n
template<typename... bases>\nstruct Aggregator : bases...\n{\n    template<typename Visitor>\n    void for_each_base(Visitor&& visitor)\n    {\n        (void(visitor(static_cast<bases*>(this))), ...);\n    }\n\n    template<typename Visitor>\n    static void static_for_each_base(Visitor&& visitor)\n    {\n        (void(visitor(static_cast<bases*>(nullptr))), ...);\n    }\n};\n\nclass PillowRadio : Aggregator<Pillow, Radio>\n{\npublic:\n    int price()\n    {\n        int total = 10; \/* extra 10 for packaging *\/\n        for_each_base([&](auto* base) { total += base->price(); });\n        return total;\n    }\n\n    static int list_price()\n    {\n        int total = 10; \/* extra 10 for packaging *\/\n        static_for_each_base([&](auto* base) {\n            using Base = std::decay_t<decltype(*base)>;\n            total += Base::list_price();\n        });\n        return total;\n    }\n};\n<\/pre>\n\n\n\n
This aligns the two versions, but it may also make it easier to mistakenly move code from the non-static version to static version without realizing that the meaning of the pointer has changed. I\u2019ll let you decide which is better.<\/p>\n\n\n\n
A final consolidation could be merging the instance and static versions by taking an explicit starting point for the aggregator, either null or non-null.<\/p>\n\n\n\n
template<typename... bases>\nstruct Aggregator : bases...\n{\n    template<typename Visitor>\n    static void for_each_base(Aggregator* self, Visitor&& visitor)\n    {\n        (void(visitor(static_cast<bases*>(self))), ...);\n    }\n};\n\nclass PillowRadio : Aggregator<Pillow, Radio>\n{\npublic:\n    int price()\n    {\n        int total = 10; \/* extra 10 for packaging *\/\n        for_each_base(this, [&](auto* base) { total += base->price(); });\n        return total;\n    }\n\n    static int list_price()\n    {\n        int total = 10; \/* extra 10 for packaging *\/\n        \/\/ C++20: [&]<typename Base>(Base*) {\n        for_each_base(nullptr, [&](auto* base) {\n            using Base = std::decay_t<decltype(*base)>;\n            total += Base::list_price();\n        });\n        return total;\n    }\n};\n<\/pre>\n\n\n\n
\u00b9 Though fans of a Swedish children\u2019s television show from 2004<\/a> may remember an episode that involved such a contraption, with the obvious name kudderadio<\/em>. (Sorry, I couldn\u2019t find a link to the kudderadio<\/em> episode.)<\/p>\n\n\n\n
\n\n\n\n