![\"IdiomsPolymorphismTemplates\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/03\/IdiomsPolymorphismTemplates.png\")
<\/p>\nThis post is unique because I have written about all the topics mentioned in this post already. Therefore, I only provide a few words about the topic and a link to the post mentioned.<\/p>\n
<\/p>\n
<\/p>\n
I decided on this particular post for two reasons. First, all the idioms for polymorphism and templates in C++ are very important and often used. Second, I don’t write posts about topics I have already a few months ago written about.<\/p>\n
Polymorphism is the property that different types support the same interface. In C++, we distinguish between dynamic polymorphism and static polymorphism.<\/p>\n
Dynamic Polymorphism takes place at run time, based on object orientation, and enables us to separate between the interface and the implementation of a class hierarchy. To get late binding, dynamic dispatch, or dispatch at run time, you need virtuality and an indirection such as a pointer or a reference.<\/p>\n
Here is the crucial idea of CRTP: A class <\/p>\n <\/p>\n Static polymorphism is based on CRTP.<\/p>\n Static polymorphism happens at compile time and has no runtime performance cost.<\/p>\n <\/p>\n <\/p>\n Templates extend C++ with many new idioms.<\/p>\n Mixins<\/a> are a popular idea in the design of classes to mix in new code. You can implement mixins in C++ by using CRTP. A prominent example is the class std::enable_shared_from_this<\/a>.<\/p>\n Expression templates are typically used in linear algebra and are “structures representing a computation at compile-time, which structures are evaluated only as needed to produce efficient code for the entire computation” (https:\/\/en.wikipedia.org\/wiki\/Expression_templates<\/a>). In other words, expression templates are only evaluated when needed. <\/p>\n A policy is a generic function or class whose behavior can be configured. Typically, there are default values for the policy parameters. <\/p>\n <\/p>\n Traits are class templates that provide characteristics of a generic type. They can extract one or more characteristics of a class template.<\/p>\n Tag dispatching is a way to simulate function overloading based on concepts, often based on traits.<\/p>\n Type Erasure enables using various concrete types through a single generic interface. In C, you base it on void pointers; in C++, on object orientation or templates.<\/p>\nDerived<\/code> derives from a class template Base<\/code>, and Base<\/code> has Derived<\/code> as a template argument.<\/p>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Base<\/span> {\r\n ...\r\n};\r\n\r\nclass<\/span> Derived<\/span> :<\/span> public<\/span> Base<<\/span>Derived><\/span> {\r\n ...\r\n};\r\n<\/pre>\n<\/div>\n\n
<\/span>Static Polymorphism<\/span><\/h3>\n
\n
<\/span>The Overload Pattern<\/span><\/h3>\n
<\/code><\/a>Typically, you use the overload pattern for a std::variant<\/code><\/a>. std::variant<\/code> is a type-safe union. with one value from one of its types. std::visit <\/a>allows you to apply a visitor to it. Exactly here comes the Overload Pattern in C++20 very handy in play.<\/p>\n\ntemplate<\/span><<\/span>typename<\/span> ... Ts><\/span> \r\nstruct<\/span> Overload :<\/span> Ts ... { \r\n using<\/span> Ts::<\/span>operator<\/span>() ... ; \r\n};\r\n<\/pre>\n<\/div>\n\n
<\/span>Templates<\/span><\/h2>\n
<\/span>Mixins<\/span><\/h3>\n
\n
<\/span>Expression Templates<\/span><\/h3>\n
\n
<\/span>Policy<\/span><\/h3>\n
std::vector<\/code> and std::unordered_map<\/code> exemplify this design idea in the Standard Template Library.<\/p>\n\ntemplate<\/span><<\/span>class<\/span> T<\/span>, class<\/span> Allocator<\/span> std::<\/span>allocator<<\/span>T>><\/span> \r\nclass<\/span> vector<\/span>; \r\n\r\ntemplate<\/span><<\/span>class<\/span> Key<\/span>,\r\n class<\/span> T<\/span>,\r\n class<\/span> Hash<\/span> =<\/span> std::<\/span>hash<<\/span>Key><\/span>, \r\n class<\/span> KeyEqual<\/span> =<\/span> std::<\/span>equal_to<<\/span>Key><\/span>, \r\n class<\/span> allocator<\/span> =<\/span> std::<\/span>allocator<<\/span>std::<\/span>pair<<\/span>const<\/span> Key, T>><\/span> \r\nclass<\/span> unordered_map<\/span>;\r\n<\/pre>\n<\/div>\n\n
<\/span>Traits<\/span><\/h3>\n
\n
<\/span>Tag Dispatching<\/span><\/h3>\n
\n
<\/span>Type Erasure<\/span><\/h3>\n