When speaking of polymorphism immediately the first things that come to our mind are virtual functions and v-tables (C++).<\/p>\n\n\n\n
You declare a virtual function in a base class and then you override it in derived classes.<\/p>\n\n\n\n
When you call such a function on a reference or a pointer to the base class, then the compiler will invoke the correct overload. In most cases, compilers implement this technique with virtual tables (v-tables). Each class that has a virtual method contains an extra table that points to the addresses of the member functions. Before each call to a virtual method, the compiler needs to look at v-table and resolve the address of a derived function at runtime (it is called late method binding).<\/p>\n\n\n\n
An example below demonstrates a Vehicle base class with some interface and derived class (Pickup, Truck) which derive from it in a standard way.<\/p>\n\n\n\n
![\"kod\"](\"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/11\/Ryc.-1.png\")
<\/a><\/figure><\/div>\n\n\n\n<\/a><\/figure><\/div>\n\n\n\n<\/a><\/figure><\/div>\n\n\n\nPros and Cons of run-time polymorphism with virtual functions<\/strong><\/h2>\n\n\n\nPros<\/strong><\/p>\n\n\n\n- it is very convenient to extend with new class,<\/li>
- object orientation allows deep hierarchies,<\/li>
- storing heterogeneous types in a single container is easy, just store pointers to the Base class or to the abstract class (interface).<\/li><\/ul>\n\n\n\n
Cons<\/strong><\/p>\n\n\n\n- virtual methods must be resolved before the call (performance overhead),<\/li>
- since you need a pointer to call a method, usually it means dynamic allocation (more performance overhead),<\/li>
- you need to modify the code of all classes in the inheritance structure.<\/li><\/ul>\n\n\n\n
Std::variant polymorphism<\/strong><\/h2>\n\n\n\nThe class template std::variant<\/strong> represents a type-safe union<\/strong>. An instance of std::variant<\/strong> at any given time either holds a value of one of its alternative types or in the case of error \u2013 no value.<\/p>\n\n\n\nWith this approach, there is no Vehicle<\/strong> class needed anymore as in the previous example. We can create more unrelated types here. The vehicles variable defines an object that can be a Pickup<\/strong> or Truck<\/strong>. In order to call a function we need a callable object and std::visit.<\/p>\n\n\n\nA struct callPrintName<\/strong> implements overloads for the call operator. Then std::visit<\/strong> takes the variant object and calls the correct overload. std :: visit is a powerful tool that allows you to call functions on the current type stored inside std :: variant. It can find the appropriate function overloads, and what’s more, it works for multiple variants at once.<\/p>\n\n\n\n![\"code\"](\"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/11\/Fig.-4.png\")
<\/a><\/figure><\/div>\n\n\n\n![\"schema\"](\"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/11\/Fig.-5.png\")
<\/a><\/figure><\/div>\n\n\n\nThis can be simplified and the callable object callPrintName<\/strong> can be replaced with generic lambdas if our variant subtypes share common interface.<\/p>\n\n\n\n![\"code\"](\"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/11\/Fig.-6.png\")
<\/a><\/figure><\/div>\n\n\n\nWhat if we need some arguments? The main issues is that std::visit<\/strong> does not have a way to pass arguments into the callable object. It only takes a function object and a list of std::variant<\/strong> objects.<\/p>\n\n\n\nOne option is to create a custom functor:<\/p>\n\n\n\n
![\"code\"](\"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/11\/Fig.-7.png\")
<\/a><\/figure><\/div>\n\n\n\nThe other options to solve it by capturing the argument and forwarding it to a member function<\/p>\n\n\n\n
![\"code\"](\"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/11\/Fig.-8.png\")
<\/a><\/figure><\/div>\n\n\n\nThe Overload pattern<\/strong><\/h2>\n\n\n\nThe overload pattern is useful for wrapping multiple separate lambdas into an overload set. The code is shorter and there is no need to declare a structure that holds operator()<\/strong> overloads. In C++17 it required 2 lines of code to be implemented:<\/p>\n\n\n\n![\"\"](\"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2022\/11\/Fig.-9.png\")
<\/a><\/figure><\/div>\n\n\n\nThe first line is the overload pattern, the second is the deduction guide for it. The struct Overloaded<\/strong><\/p>\n\n\n\ncan have arbitrary many base classes. It derives from each class and brings the call operator(Ts::operator..<\/strong>) of each base class into the scope. The base classes need an overloaded call operator (Ts::operator())<\/strong>. Lambdas provide this call operator. <\/p>\n\n\n\nExample:<\/p>\n\n\n\n
- it is very convenient to extend with new class,<\/li>
- object orientation allows deep hierarchies,<\/li>
- storing heterogeneous types in a single container is easy, just store pointers to the Base class or to the abstract class (interface).<\/li><\/ul>\n\n\n\n
Cons<\/strong><\/p>\n\n\n\n
- virtual methods must be resolved before the call (performance overhead),<\/li>
- since you need a pointer to call a method, usually it means dynamic allocation (more performance overhead),<\/li>
- you need to modify the code of all classes in the inheritance structure.<\/li><\/ul>\n\n\n\n
Std::variant polymorphism<\/strong><\/h2>\n\n\n\n
The class template std::variant<\/strong> represents a type-safe union<\/strong>. An instance of std::variant<\/strong> at any given time either holds a value of one of its alternative types or in the case of error \u2013 no value.<\/p>\n\n\n\n
With this approach, there is no Vehicle<\/strong> class needed anymore as in the previous example. We can create more unrelated types here. The vehicles variable defines an object that can be a Pickup<\/strong> or Truck<\/strong>. In order to call a function we need a callable object and std::visit.<\/p>\n\n\n\n
A struct callPrintName<\/strong> implements overloads for the call operator. Then std::visit<\/strong> takes the variant object and calls the correct overload. std :: visit is a powerful tool that allows you to call functions on the current type stored inside std :: variant. It can find the appropriate function overloads, and what’s more, it works for multiple variants at once.<\/p>\n\n\n\n
<\/a><\/figure><\/div>\n\n\n\n<\/a><\/figure><\/div>\n\n\n\nThis can be simplified and the callable object callPrintName<\/strong> can be replaced with generic lambdas if our variant subtypes share common interface.<\/p>\n\n\n\n
<\/a><\/figure><\/div>\n\n\n\nWhat if we need some arguments? The main issues is that std::visit<\/strong> does not have a way to pass arguments into the callable object. It only takes a function object and a list of std::variant<\/strong> objects.<\/p>\n\n\n\n
One option is to create a custom functor:<\/p>\n\n\n\n
<\/a><\/figure><\/div>\n\n\n\nThe other options to solve it by capturing the argument and forwarding it to a member function<\/p>\n\n\n\n
<\/a><\/figure><\/div>\n\n\n\nThe Overload pattern<\/strong><\/h2>\n\n\n\n
The overload pattern is useful for wrapping multiple separate lambdas into an overload set. The code is shorter and there is no need to declare a structure that holds operator()<\/strong> overloads. In C++17 it required 2 lines of code to be implemented:<\/p>\n\n\n\n
<\/a><\/figure><\/div>\n\n\n\nThe first line is the overload pattern, the second is the deduction guide for it. The struct Overloaded<\/strong><\/p>\n\n\n\n
can have arbitrary many base classes. It derives from each class and brings the call operator(Ts::operator..<\/strong>) of each base class into the scope. The base classes need an overloaded call operator (Ts::operator())<\/strong>. Lambdas provide this call operator. <\/p>\n\n\n\n
Example:<\/p>\n\n\n\n