{"id":6309,"date":"2022-02-25T07:17:10","date_gmt":"2022-02-25T07:17:10","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/more-about-dynamic-and-static-polymorhism\/"},"modified":"2023-06-26T09:12:32","modified_gmt":"2023-06-26T09:12:32","slug":"more-about-dynamic-and-static-polymorhism","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/more-about-dynamic-and-static-polymorhism\/","title":{"rendered":"More about Dynamic and Static Polymorphism"},"content":{"rendered":"

In my last post, “Dynamic and Static Polymorphism<\/a>“, I introduced dynamic polymorphism. Today, I continue with static polymorphism and present a very interesting idiom in C++: curiously recurring template pattern (CRTP).<\/p>\n

<\/p>\n

 \"\"<\/p>\n

A short recap. This is where I left in my last post.<\/p>\n

Dynamic Polymorphism is based on object orientation and enables us to separate between the interface and the implementation of a class hierarchy. To get late dynamic dispatch, you need two ingredients: virtuality and an indirection such as a pointer or a reference. The following program exemplified dynamic polymorphism:<\/p>\n

<\/p>\n

\n
\/\/ dispatchDynamicPolymorphism.cpp<\/span>

#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n\r\nauto<\/span> start =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();\r\n\r\nvoid<\/span> writeElapsedTime<\/span>(){\r\n    auto<\/span> now =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();\r\n    std::<\/span>chrono::<\/span>duration<<\/span>double<\/span>><\/span> diff =<\/span> now -<\/span> start;\r\n  \r\n    std::<\/span>cerr <<<\/span> diff.count() <<<\/span> \" sec. elapsed: \"<\/span>;\r\n}\r\n\r\nstruct<\/span> MessageSeverity{                         \r\n\tvirtual<\/span> void<\/span> writeMessage() const<\/span> {         \r\n\t\tstd::<\/span>cerr <<<\/span> \"unexpected\"<\/span> <<<\/span> '\\n'<\/span>;\r\n\t}\r\n};\r\n\r\nstruct<\/span> MessageInformation:<\/span> MessageSeverity{     \r\n\tvoid<\/span> writeMessage() const<\/span> override {        \r\n\t\tstd::<\/span>cerr <<<\/span> \"information\"<\/span> <<<\/span> '\\n'<\/span>;\r\n\t}\r\n};\r\n\r\nstruct<\/span> MessageWarning:<\/span> MessageSeverity{         \r\n\tvoid<\/span> writeMessage() const<\/span> override {        \r\n\t\tstd::<\/span>cerr <<<\/span> \"warning\"<\/span> <<<\/span> '\\n'<\/span>;\r\n\t}\r\n};\r\n\r\nstruct<\/span> MessageFatal:<\/span> MessageSeverity{};\r\n\r\nvoid<\/span> writeMessageReference<\/span>(const<\/span> MessageSeverity&<\/span> messServer){   \/\/ (1)<\/em><\/span>\r\n\t\r\n\twriteElapsedTime();\r\n\tmessServer.writeMessage();\r\n\t\r\n}\r\n\r\nvoid<\/span> writeMessagePointer<\/span>(const<\/span> MessageSeverity*<\/span> messServer){    \/\/ (2)<\/span>\r\n\t\r\n\twriteElapsedTime();\r\n\tmessServer-><\/span>writeMessage();\r\n\t\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n    MessageInformation messInfo;\r\n    MessageWarning messWarn;\r\n    MessageFatal messFatal;\r\n  \r\n    MessageSeverity&<\/span> messRef1 =<\/span> messInfo;        <\/span><\/em>     \r\n    MessageSeverity&<\/span> messRef2 =<\/span> messWarn;        <\/span><\/em>\r\n    MessageSeverity&<\/span> messRef3 =<\/span> messFatal;      \r\n  \r\n    writeMessageReference(messRef1);              \r\n    writeMessageReference(messRef2);\r\n    writeMessageReference(messRef3);\r\n  \r\n    std::<\/span>cerr <<<\/span> '\\n'<\/span>;\r\n  \r\n    MessageSeverity*<\/span> messPoin1 =<\/span> new<\/span> MessageInformation;   \r\n    MessageSeverity*<\/span> messPoin2 =<\/span> new<\/span> MessageWarning;       <\/em>\r\n    MessageSeverity*<\/span> messPoin3 =<\/span> new<\/span> MessageFatal;         <\/em>\r\n  \r\n    writeMessagePointer(messPoin1);               \r\n    writeMessagePointer(messPoin2);\r\n    writeMessagePointer(messPoin3);\r\n  \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Static polymorphism is based on templates. Refactor the program using the C<\/strong>uriously R<\/strong>ecurring T<\/strong>emplate P<\/strong>attern (CRTP).<\/p>\n<\/p>\n
Static Polymorphism<\/h2>\n
Before I refactor the previous program dispatchDynamicPolymorphism.cpp, <\/code>here is the key idea of CRTP: A class Derived<\/code> derives from a class template Base<\/code> and Base<\/code> has Derived<\/code> as a template argument.<\/p>\n
\n
template<\/span> <<\/span>typename<\/span> T><\/span>\r\nclass<\/span> Base<\/span>\r\n{\r\n    ...\r\n};\r\n\r\nclass<\/span> Derived<\/span> :<\/span> public<\/span> Base<<\/span>Derived><\/span>\r\n{\r\n    ...\r\n};\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Here is the pure nature of CRTP:<\/p>\n
<\/p>\n
\n
\/\/ crtp.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Derived><\/span>\r\nstruct<\/span> Base{\r\n  void<\/span> interface(){                              \/\/ (2)<\/span><\/em>\r\n    static_cast<\/span><<\/span>Derived*><\/span>(this<\/span>)-><\/span>implementation();\r\n  }\r\n  void<\/span> implementation(){                        \/\/ (3)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"Implementation Base\"<\/span> <<<\/span> std::<\/span>endl;\r\n  }\r\n};\r\n\r\nstruct<\/span> Derived1:<\/span> Base<<\/span>Derived1><\/span>{\r\n  void<\/span> implementation(){\r\n    std::<\/span>cout <<<\/span> \"Implementation Derived1\"<\/span> <<<\/span> std::<\/span>endl;\r\n  }\r\n};\r\n\r\nstruct<\/span> Derived2:<\/span> Base<<\/span>Derived2><\/span>{\r\n  void<\/span> implementation(){\r\n    std::<\/span>cout <<<\/span> \"Implementation Derived2\"<\/span> <<<\/span> std::<\/span>endl;\r\n  }\r\n};\r\n\r\nstruct<\/span> Derived3:<\/span> Base<<\/span>Derived3><\/span>{};             \/\/ (4)<\/span><\/em>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>                          \/\/ (1)<\/span>\r\nvoid<\/span> execute(T&<\/span> base){\r\n    base.interface();\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n';\r\n  \r\n  Derived1 d1;\r\n  execute(d1);\r\n    \r\n  Derived2 d2;\r\n  execute(d2);\r\n  \r\n  Derived3 d3;\r\n  execute(d3);\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n';\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I use in the function template execute<\/code> (line 1) static polymorphism. Each base<\/span> invoked the method base.interface<\/code>.<\/span> The member function Base::interface<\/code> (line 2) is the key point of the CRTP idiom. The member function dispatches to the implementation of the derived class<\/em>: static_cast<Derived*>(this)->implementation()<\/span>.  That is possible because the method will be instantiated when called. At this point in time the derived classes Derived1, Derived2<\/code>, and Derived3 are fully defined. Therefore, the method Base::interface<\/span> <\/span>can use the implementation of its derived classes. Pretty interesting is the member function Base::implementation<\/span> (line 3). This function plays the role of a default implementation for the static polymorphism for the class  Derived3 <\/code>(line 4).<\/p>\n
Here is the output of the program:<\/p>\n
 \"crtp\"<\/p>\n
Now, let me take the next step and refactor the program dispatchDynamicPolymorphism.cpp.<\/code><\/p>\n
\n
\/\/ dispatchStaticPolymorphism.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n\r\nauto<\/span> start =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();\r\n\r\nvoid<\/span> writeElapsedTime<\/span>(){\r\n    auto<\/span> now =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();\r\n    std::<\/span>chrono::<\/span>duration<<\/span>double<\/span>><\/span> diff =<\/span> now -<\/span> start;\r\n  \r\n    std::<\/span>cerr <<<\/span> diff.count() <<<\/span> \" sec. elapsed: \"<\/span>;\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> ConcreteMessage><\/span>                        \/\/ (1)<\/span>\r\nstruct<\/span> MessageSeverity{\r\n  void<\/span> writeMessage(){                                     \/\/ (2)<\/span>\r\n    static_cast<\/span><<\/span>ConcreteMessage*><\/span>(this<\/span>)-><\/span>writeMessageImplementation();\r\n  }\r\n  void<\/span> writeMessageImplementation() const<\/span> {\r\n    std::<\/span>cerr <<<\/span> \"unexpected\"<\/span> <<<\/span> std::<\/span>endl;\r\n  }\r\n};\r\n\r\nstruct<\/span> MessageInformation:<\/span> MessageSeverity<<\/span>MessageInformation><\/span>{\r\n  void<\/span> writeMessageImplementation() const<\/span> {               \/\/ (3)<\/span>\r\n    std::<\/span>cerr <<<\/span> \"information\"<\/span> <<<\/span> std::<\/span>endl;\r\n  }\r\n};\r\n\r\nstruct<\/span> MessageWarning:<\/span> MessageSeverity<<\/span>MessageWarning><\/span>{\r\n  void<\/span> writeMessageImplementation() const<\/span> {               \/\/ (4)<\/span>\r\n    std::<\/span>cerr <<<\/span> \"warning\"<\/span> <<<\/span> std::<\/span>endl;\r\n  }\r\n};\r\n\r\nstruct<\/span> MessageFatal:<\/span> MessageSeverity<<\/span>MessageFatal><\/span>{};     \/\/ (5)<\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> writeMessage(T&<\/span> messServer){                       \r\n\t\r\n    writeElapsedTime();                                   \r\n    messServer.writeMessage();                            \/\/ (6)<\/span>\r\n\t\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n  \r\n    MessageInformation messInfo;\r\n    writeMessage(messInfo);\r\n    \r\n    MessageWarning messWarn;\r\n    writeMessage(messWarn);\r\n\t\r\n    MessageFatal messFatal;\r\n    writeMessage(messFatal);\r\n  \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
In this case, all concrete classes (lines 3, 4, and 5) derive from the base class MessageSeverity<\/code>. The member function writeMessage <\/code>is the interface that dispatches to the concrete implementations writeMessageImplementation<\/code>. To achieve this, the object will be upcasted to the ConcreteMessage:  static_cast<ConcreteMessage*>(this)->writeMessageImplementation();<\/code>. <\/span>This is the static dispatch at compile time and coined the name for this technique: static polymorphism.<\/p>\n
It took me time to get used to it, but applying the static polymorphism in line (6) is quite easy.<\/p>\n
In the end, I want to compare dynamic and static polymorphism in a few words:<\/p>\n
Dynamic Versus Static Polymorphism<\/a><\/h2>\n
Dynamic polymorphism happens at run time, and static polymorphism at compile time. Dynamic polymorphism typically requires a pointer indirection at run time (read the post “Demystifying virtual functions, Vtable, and VPTR in C++<\/a>“), but static polymorphism has no performance costs at run time. Admittedly, there is a reason why the idiom curiously recurring template pattern (CRTP) has the name curious inside. For beginners, the idiom is quite challenging to understand. So, what should you use?<\/p>\n
First of all, don’t overestimate the costs of a virtual dispatch. In most cases, you can ignore them. Read the excellent paper “Technical Report on C++ Performance<\/a>” for details. It’s pretty dated but has in section 5.3.3 exciting numbers about the additional costs of virtual function calls. If you are still concerned about performance, there is only one cure: measure. Put your performance tests under version control. Always rerun them if something in your setup consisting of your hardware, compiler, or compiler version changes because this invalidates your previous performance numbers.<\/p>\n
In the end, code is way more often read the written. Therefore, you should use the techniques your team is most comfortable with.  <\/p>\n
What’s next?<\/h2>\n
Mixins<\/a> are a widespread technique in Python. They allow you to change the behavior of a class using multiple inheritances. Thanks to CRTP, we also have mixins in C++. Read about them in my next post.<\/p>\n
 <\/p>\n<\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
In my last post, “Dynamic and Static Polymorphism“, I introduced dynamic polymorphism. Today, I continue with static polymorphism and present a very interesting idiom in C++: curiously recurring template pattern (CRTP).<\/p>\n","protected":false},"author":21,"featured_media":6303,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[427],"class_list":["post-6309","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates","tag-polymorphism"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6309","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=6309"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6309\/revisions"}],"predecessor-version":[{"id":6680,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6309\/revisions\/6680"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6303"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6309"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6309"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6309"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}