Suppose you have a class with multiple base classes, and you want to invoke a method on all of the base classes.<\/p>\n
For example, say we have And you want to create a 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 The point is that you may have cases where you want to iterate over your base classes and aggregate the results.<\/p>\n So how do you do this?<\/p>\n C++ doesn’t provide this degree of reflection but you can simulate it by introducing a helper class.<\/p>\n How does this work?<\/p>\n The The methods on For the case of Of course, this The Now we can implement the aggregator methods for our Okay, but what about static members?<\/p>\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 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 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>\nPillow<\/code> and Radio<\/code> classes:<\/p>\nclass Pillow\r\n{\r\npublic:\r\n int price();\r\n int weight();\r\n void refurbish(int level);\r\n};\r\n\r\nclass Radio\r\n{\r\npublic:\r\n int price();\r\n int weight();\r\n void refurbish(int level);\r\n};\r\n<\/pre>\nPillowRadio<\/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’s go along with it.<\/p>\nclass PillowRadio : public Pillow, public Radio\r\n{\r\npublic:\r\n int price()\r\n {\r\n int total = 0;\r\n for (typename T : base_classes_of(this)) {\r\n total += T::price();\r\n }\r\n return total + 10; \/* extra 10 for packaging *\/\r\n }\r\n\r\n int weight()\r\n {\r\n int total = 0;\r\n for (typename T : base_classes_of(this)) {\r\n total += T::weight();\r\n }\r\n return total + 5; \/* extra 5 for packaging *\/\r\n }\r\n\r\n void refurbish(int level)\r\n {\r\n for (typename T : base_classes_of(this)) {\r\n T::refurbish(level);\r\n }\r\n }\r\n};\r\n<\/pre>\ntemplate<typename... bases>\r\nstruct Aggregator : bases...\r\n{\r\n int price()\r\n {\r\n return (0 + ... + bases::price());\r\n }\r\n\r\n int weight()\r\n {\r\n return (0 + ... + bases::weight());\r\n }\r\n\r\n void refurbish(int level)\r\n {\r\n (bases::refurbish(level), ...);\r\n }\r\n};\r\n\r\nclass PillowRadio : Aggregator<Pillow, Radio>\r\n{\r\npublic:\r\n int price()\r\n {\r\n return Aggregator::price() + 10; \/* extra 10 for packaging *\/\r\n }\r\n\r\n int weight()\r\n {\r\n return Aggregator::weight() + 5; \/* extra 5 for packaging *\/\r\n }\r\n\r\n \/* inherit refurbish from Aggregator *\/\r\n};\r\n<\/pre>\nAggregator<\/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>\nAggregator<\/code> use fold expressions<\/a> which iterate over the template type parameters and combine the results in some way.<\/p>\nrefurbish<\/code>, we don’t 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’t have to worry about somebody doing a sneaky overload of the comma operator<\/a>.<\/p>\nAggregator<\/code> is tightly coupled to the methods of its base classes. Maybe we can generalize it.<\/p>\ntemplate<typename... bases>\r\nstruct Aggregator : bases...\r\n{\r\n template<typename Visitor>\r\n void for_each_base(Visitor&& visitor)\r\n {\r\n (void(visitor(static_cast<bases&>(*this))), ...);\r\n }\r\n};\r\n<\/pre>\nfor_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>\nPillowRadio<\/code> class.<\/p>\nclass PillowRadio : Aggregator<Pillow, Radio>\r\n{\r\npublic:\r\n int price()\r\n {\r\n int total = 10; \/* extra 10 for packaging *\/\r\n for_each_base([&](auto&& base) { total += base.price(); });\r\n return total;\r\n }\r\n\r\n int weight()\r\n {\r\n int total = 5; \/* extra 5 for packaging *\/\r\n for_each_base([&](auto&& base) { total += base.weight(); });\r\n return total;\r\n }\r\n\r\n void refurbish(int level)\r\n {\r\n for_each_base([&](auto&& base) { base.refurbish(level); });\r\n }\r\n};\r\n<\/pre>\ntemplate<typename... bases>\r\nstruct Aggregator : bases...\r\n{\r\n template<typename Visitor>\r\n void for_each_base(Visitor&& visitor)\r\n {\r\n (void(visitor(static_cast<bases&>(*this))), ...);\r\n }\r\n\r\n template<typename Visitor>\r\n static void static_for_each_base(Visitor&& visitor)\r\n {\r\n (void(visitor(static_cast<bases*>(nullptr))), ...);\r\n }<\/span>\r\n};\r\n<\/pre>\nclass Pillow\r\n{\r\npublic:\r\n static int list_price();\r\n};\r\n\r\nclass Radio\r\n{\r\npublic:\r\n static int list_price();\r\n};\r\n\r\nclass PillowRadio : Aggregator<Pillow, Radio>\r\n{\r\npublic:\r\n static int list_price()\r\n {\r\n int total = 10; \/* extra 10 for packaging *\/\r\n static_for_each_base([&](auto* base) {\r\n using Base = std::decay_t<decltype(*base)>;\r\n total += Base::list_price();\r\n });\r\n return total;\r\n }\r\n};\r\n<\/pre>\n