{"id":7769,"date":"2023-07-24T13:08:06","date_gmt":"2023-07-24T13:08:06","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=7769"},"modified":"2023-08-23T17:01:05","modified_gmt":"2023-08-23T17:01:05","slug":"c23-syntactic-sugar-with-deducing-this","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c23-syntactic-sugar-with-deducing-this\/","title":{"rendered":"C++23: Syntactic Sugar with Deducing This"},"content":{"rendered":"\n

The C<\/strong>uriously R<\/strong>ecurring T<\/strong>emplate P<\/strong>attern (CRTP) is a heavily used idiom in C++. It is similarly resistant to understanding as the classic design pattern visitor I presented in my last post: “C++23: Deducing This<\/a>“.  Thanks to deducing this, we can remove the C and R from the abbreviation.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

CRTP<\/h2>\n\n\n\n

The acronym CRTP stands for the C++ idiom C<\/strong>uriously R<\/strong>ecurring T<\/strong>emplate P<\/strong>attern and denotes a technique in C++ in which a class Derived<\/code> is derived from a class template Base<\/code>. The critical point is that Base<\/code> has Derived<\/code> as a template argument.<\/p>\n\n\n\n\n

\n
template<\/span> <<\/span>typename<\/span> T><\/span>\nclass<\/span> Base<\/span>{\n    ...\n};\n\nclass<\/span> Derived<\/span> :<\/span> public<\/span> Base<<\/span>Derived><\/span>{\n    ...\n};\n<\/pre>\n<\/div>\n\n\n\n
CRTP is typically used to implement static polymorphism. Unlike dynamic polymorphism, static polymorphism happens at compile time and does not require an expensive<\/em> run-time pointer indirection.<\/p>\n\n\n\n
C++98<\/h3>\n\n\n\n
The following program crtp.cpp<\/code> shows an idiomatic C++98-based implementation of CRTP.<\/p>\n\n\n\n
\/\/ crtp.cpp<\/span>\n\n#include <iostream><\/span>\n\ntemplate<\/span> <<\/span>typename<\/span> Derived><\/span>\nstruct<\/span> Base{                                        \n  void<\/span> interface(){                                 \/\/ (2)<\/span>\n    static_cast<\/span><<\/span>Derived*><\/span>(this<\/span>)-><\/span>implementation();\n  }\n  void<\/span> implementation(){                            \/\/ (3)<\/span>\n    std::<\/span>cout <<<\/span> "Implementation Base"<\/span> <<<\/span> '\\n'<\/span>;\n  }\n};\n\nstruct<\/span> Derived1:<\/span> Base<<\/span>Derived1><\/span>{\n  void<\/span> implementation(){\n    std::<\/span>cout <<<\/span> "Implementation Derived1"<\/span> <<<\/span> '\\n'<\/span>;\n  }\n};\n\nstruct<\/span> Derived2:<\/span> Base<<\/span>Derived2><\/span>{\n  void<\/span> implementation(){\n    std::<\/span>cout <<<\/span> "Implementation Derived2"<\/span> <<<\/span> '\\n'<\/span>;\n  }\n};\n\nstruct<\/span> Derived3:<\/span> Base<<\/span>Derived3><\/span>{};                \/\/ (4)<\/span>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>                             \/\/ (1)<\/span>\nvoid<\/span> execute(T&<\/span> base){\n    base.interface();                              \n}\n\nint<\/span> main(){\n  \n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\n  \n  Derived1 d1;\n  execute(d1);\n    \n  Derived2 d2;\n  execute(d2);\n  \n  Derived3 d3;\n  execute(d3);\n  \n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\n  \n}\n<\/pre><\/div>\n\n\n\n
The function template execute<\/code> (1) uses static polymorphism. The member function base::interface<\/code> (2) is the key to the CRTP idiom. The member function forwards to the implementation of the derived class: static_cast<derived*>(this)->implementation<\/code>. This is possible because the function is not instantiated until it is called. The derived classes Derived1<\/code>, Derived2<\/code> and Derived3<\/code> are defined at this point. Therefore, the function Base::interface<\/code> can use the implementation of the derived classes. The member function Base::implementation<\/code> (3) plays the role of a default implementation for the static polymorphism of the class Derived3<\/code> (4). <\/p>\n\n\n\n
The following screenshot shows the static polymorphism in action.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
C++23<\/h3>\n\n\n\n
Thanks to the explicit object parameter (deducing this), the C and the R can be removed from the CRTP acronym:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
The program deducingThisCRTP.cpp<\/code> shows the C++23-based implementation of CR<\/s>TP.<\/p>\n\n\n\n
\/\/ deducingThisCRTP.cpp<\/span>\n\n#include <iostream><\/span>\n\nstruct<\/span> Base{                                            \/\/ (1)<\/span>\n  template<\/span> <<\/span>typename<\/span> Self><\/span>\n  void<\/span> interface(this<\/span> Self&&<\/span> self){\n    self.implementation();\n  }\n  void<\/span> implementation(){\n    std::<\/span>cout <<<\/span> "Implementation Base"<\/span> <<<\/span> '\\n'<\/span>;\n  }\n};\n\nstruct<\/span> Derived1:<\/span> Base{\n  void<\/span> implementation(){\n    std::<\/span>cout <<<\/span> "Implementation Derived1"<\/span> <<<\/span> '\\n'<\/span>;\n  }\n};\n\nstruct<\/span> Derived2:<\/span> Base{\n  void<\/span> implementation(){\n    std::<\/span>cout <<<\/span> "Implementation Derived2"<\/span> <<<\/span> '\\n'<\/span>;\n  }\n};\n\nstruct<\/span> Derived3:<\/span> Base{};\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nvoid<\/span> execute(T&<\/span> base){\n    base.interface();                                 \/\/ (2)<\/span>\n}\n\nint<\/span> main(){\n  \n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\n  \n  Derived1 d1;                                        \/\/ (3)<\/span>\n  execute(d1);\n    \n  Derived2 d2;                                        \/\/ (4)<\/span>\n  execute(d2);\n  \n  Derived3 d3;                                        \/\/ (5)<\/span>\n  execute(d3);\n  \n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\n  \n}\n<\/pre><\/div>\n\n\n\n
Thanks to the explicit object parameter (line 1), the type of the explicit object parameter can be deduced to the derived type and perfectly forwarded. For the concrete type in (2), Derived1<\/code> (3), Derived2<\/code> (4), and Derived3<\/code> (5) are used. Consequently, the corresponding virtual <\/em>function implementation is called: std::forward<Self>(self).implementation()<\/code>. With the current Microsoft compiler, the program can already be executed:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Recursive Lambdas<\/h2>\n\n\n\n
I got a comment on my last German post (https:\/\/www.heise.de\/forum\/heise-online\/Kommentare\/C-23-Deducing-This-erstellt-explizite-Zeiger\/rekursive-lambdas\/thread-7392252\/<\/a>) that I forgot the most descriptive applications of Deducing This: recursive lambdas. Honestly, I’m not so sure because most programmers have issues with recursion. Second, I’m not a fan of sophisticated lambdas. Lambdas should be concise and self-documenting.<\/p>\n\n\n\n
Let me show you various implementations of a recursively defined factorial function. Afterward, you can decide which version you prefer.<\/p>\n\n\n\n
Each factorial function calculates the factorial of 10: 3628800.<\/p>\n\n\n\n
C++98<\/h3>\n\n\n\n
In C++98, you have two options. Either you use template metaprogramming with recursive instantiation or just a function call. The template metaprogram runs at compile time.<\/p>\n\n\n\n
\/\/ factorial_cpp98.cpp<\/span>\n\n#include <iostream><\/span>\n\ntemplate<\/span> <<\/span>unsigned<\/span> int<\/span> N><\/span>                                                                 \nstruct<\/span> Factorial{\n    static<\/span> int<\/span> const<\/span> value =<\/span> N *<\/span> Factorial<<\/span>N-<\/span>1<\/span>>::<\/span>value;\n};\n\n\n\ntemplate<\/span> <><\/span>                                                                     \nstruct<\/span> Factorial<<\/span>0<\/span>><\/span>{\n    static<\/span> int<\/span> const<\/span> value =<\/span> 1<\/span>;\n};\n\nint<\/span> factorial<\/span>(unsigned<\/span> int<\/span> n){\n    return<\/span> n ><\/span> 0<\/span> ?<\/span> n *<\/span> factorial(n -<\/span> 1<\/span>):<\/span> 1<\/span>;\n}\n\nint<\/span> main<\/span>(){\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>cout <<<\/span> "Factorial<10>::value: "<\/span> <<<\/span> Factorial<<\/span>10<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>; \n    std::<\/span>cout <<<\/span> "factorial(10)         "<\/span> <<<\/span> factorial(10<\/span>) <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
I’m not sure with which version of factorial you would prefer. I probably use the C++20 version based on consteval<\/code>.<\/p>\n\n\n\n
What’s next?<\/h2>\n\n\n\n
The core language of C++23 has more features to offer than deducing this. They will be the topic of my next post.<\/p>\n","protected":false},"excerpt":{"rendered":"
The Curiously Recurring Template Pattern (CRTP) is a heavily used idiom in C++. It is similarly resistant to understanding as the classic design pattern visitor I presented in my last post: “C++23: Deducing This“.  Thanks to deducing this, we can remove the C and R from the abbreviation. CRTP The acronym CRTP stands for the […]<\/p>\n","protected":false},"author":21,"featured_media":7770,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[378],"tags":[426],"class_list":["post-7769","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-23","tag-crtp"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7769","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=7769"}],"version-history":[{"count":20,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7769\/revisions"}],"predecessor-version":[{"id":8036,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7769\/revisions\/8036"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/7770"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=7769"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=7769"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=7769"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}