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 Pros<\/strong><\/p>\n\n\n\n Cons<\/strong><\/p>\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 This 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 What 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 The other options to solve it by capturing the argument and forwarding it to a member function<\/p>\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 The 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![\"code\"](\"https:\/\/sii.ua\/blog\/wp-content\/uploads\/2024\/01\/Ryc.-1.png\")
<\/a><\/figure>\n\n\n\n<\/a><\/figure>\n\n\n\n<\/a><\/figure>\n\n\n\nPros and Cons of run-time polymorphism with virtual functions<\/strong><\/h2>\n\n\n\n
\n
\n
Std::variant polymorphism<\/strong><\/h2>\n\n\n\n
<\/a><\/figure>\n\n\n\n<\/a><\/figure>\n\n\n\n<\/a><\/figure>\n\n\n\n<\/a><\/figure>\n\n\n\n<\/a><\/figure>\n\n\n\nThe Overload pattern<\/strong><\/h2>\n\n\n\n
<\/a><\/figure>\n\n\n\n