{"id":7642,"date":"2023-07-17T15:53:09","date_gmt":"2023-07-17T15:53:09","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=7642"},"modified":"2023-08-11T15:55:54","modified_gmt":"2023-08-11T15:55:54","slug":"c23-deducing-this","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c23-deducing-this\/","title":{"rendered":"C++23: Deducing This"},"content":{"rendered":"\n

Anyone who thinks a small C++ standard follows a significant C++ standard is wrong. C++23 provides powerful extensions to C++20. These extensions include the core language, particularly the standard library. Today, I present a small but very impactful feature of the core language: deducing this.<\/p>\n\n\n\n

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

Deducing this, sometimes also called explicit object parameter, allows it to make the implicit this<\/code> pointer of a member function explicit. Like Python, the explicit object parameter must be the first function parameter and is called in C++, by convention, Self<\/code> and self<\/code>.<\/p>\n\n\n\n

struct<\/span> Test {\n    void<\/span> implicitParameter();               \/\/ implicit this pointer<\/span>\n    void<\/span> explictParameter<\/span>(this<\/span> Self&<\/span> self); \/\/ explicit this pointer<\/span>\n};\n<\/pre><\/div>\n\n\n\n
Deducing this enables new programming techniques in C++23: deduplication of function overloading based on the object’s lvalue\/rvalue value category and constness. Additionally, you can reference a lambda and invoke it recursively. Furthermore, deducing this simplifies the implementation of CRTP<\/a>.<\/p>\n\n\n\n
Deduplicating Function Overloading<\/h2>\n\n\n\n
Assume you want to overload a member function based on the lvalue\/rvalue value category and constness of the calling object. This means you have to overload your member function four times.<\/p>\n\n\n\n
\/\/ deducingThis.cpp<\/span>\n\n#include <iostream><\/span>\n\nstruct<\/span> Test {\n    template<\/span> <<\/span>typename<\/span> Self><\/span>\n    void<\/span> explicitCall(this<\/span> Self&&<\/span> self, const<\/span> std::<\/span>string&<\/span> text) {  \/\/ (9)<\/span>\n        std::<\/span>cout <<<\/span> text <<<\/span> ": "<\/span>;\n        std::<\/span>forward<<\/span>Self><\/span>(self).implicitCall();                    \/\/ (10)<\/span>\n        std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    }\n\n    void<\/span> implicitCall() &<\/span> {                          \/\/ (1)<\/span>\n        std::<\/span>cout <<<\/span> "non const lvalue"<\/span>;\n    }\n\n    void<\/span> implicitCall() const<\/span>&<\/span> {                     \/\/ (2)<\/span>\n        std::<\/span>cout <<<\/span> "const lvalue"<\/span>;\n    }\n\n    void<\/span> implicitCall() &&<\/span> {                         \/\/ (3)<\/span>\n        std::<\/span>cout <<<\/span> "non const rvalue"<\/span>;\n    }\n\n    void<\/span> implicitCall() const<\/span>&&<\/span> {                    \/\/ (4)<\/span>\n        std::<\/span>cout <<<\/span> "const rvalue"<\/span>;\n    }\n\n};\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    Test test;\n    const<\/span> Test constTest;\n\n    test.explicitCall("test"<\/span>);                                  \/\/ (5)<\/span>\n    constTest.explicitCall("constTest"<\/span>);                        \/\/ (6)<\/span>\n    std::<\/span>move(test).explicitCall("std::move(test)"<\/span>);            \/\/ (7)<\/span>\n    std::<\/span>move(constTest).explicitCall("std::move(consTest)"<\/span>);   \/\/ (8)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
Lines (1), (2), (3), and (4) are the required function overloads. Lines (1) and (2) take a non-const and const lvalue object, and lines (3) and (4) a non-const and const rvalue objects. To simplify, a lvalue is a value from which the address can be determined, and a rvalue is an only readable value. The lines (5) to (8) represent the corresponding objects. Deducing this in line (9) enables it to deduplicate the four overloads in one member function that perfectly forwards self<\/code> (line 10) and calls implicitCall<\/code>. This article goes into the intricacies of perfect forwarding: perfect forwarding<\/a>.<\/p>\n\n\n\n
Currently (July 2023), neither the brand new GCC nor Clang C++ Compiler supports this feature, but the Microsoft Visual C++ compiler partially. The following screenshot shows that the four function calls in the main function use the four different overloads of the member function implicitCall<\/code>.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
As I promised, deducing this is a pretty small future, but …<\/p>\n\n\n\n
Reference a Lambda<\/h2>\n\n\n\n
The crucial idea of the Visitor Pattern<\/a> is to perform operations on an object hierarchy. The object hierarchy is stable in this classical pattern, but the operations may change frequently.<\/p>\n\n\n\n
The Visitor Pattern<\/h3>\n\n\n\n
The following program visitor.cpp<\/code> exemplifies this pattern.<\/p>\n\n\n\n
\/\/ visitor.cpp<\/span>\n\n#include <iostream><\/span>\n#include <string><\/span>\n#include <vector><\/span>\n\nclass<\/span> CarElementVisitor<\/span>;\n\nclass<\/span> CarElement<\/span> {                                     \/\/ (5)<\/span>\n public:<\/span>\n    virtual<\/span> void<\/span> accept(CarElementVisitor&<\/span> visitor) const<\/span> =<\/span> 0<\/span>;\n    virtual<\/span> ~<\/span>CarElement() =<\/span> default<\/span>;\n};\n\nclass<\/span> Body<\/span>;\nclass<\/span> Car<\/span>;\nclass<\/span> Engine<\/span>;\nclass<\/span> Wheel<\/span>;\n\nclass<\/span> CarElementVisitor<\/span> {                              \/\/ (6)<\/span>\n public:<\/span>\n    virtual<\/span> void<\/span> visit(Body body) const<\/span> =<\/span> 0<\/span>;\n    virtual<\/span> void<\/span> visit(Car car) const<\/span> =<\/span> 0<\/span>;\n    virtual<\/span> void<\/span> visit(Engine engine) const<\/span> =<\/span> 0<\/span>;\n    virtual<\/span> void<\/span> visit(Wheel wheel) const<\/span> =<\/span> 0<\/span>;\n    virtual<\/span> ~<\/span>CarElementVisitor() =<\/span> default<\/span>;\n};\n\nclass<\/span> Wheel<\/span>:<\/span> public<\/span> CarElement {\n public:<\/span>\n    Wheel(const<\/span> std::<\/span>string&<\/span> n):<\/span> name(n) { }\n\n    void<\/span> accept(CarElementVisitor&<\/span> visitor) const<\/span> override {\n        visitor.visit(*<\/span>this<\/span>);\n    }\n\n    std::<\/span>string getName() const<\/span> {\n        return<\/span> name;\n    }\n private:<\/span>\n    std::<\/span>string name;\n};\n\nclass<\/span> Body<\/span>:<\/span> public<\/span> CarElement {\n public:<\/span>\n    void<\/span> accept(CarElementVisitor&<\/span> visitor) const<\/span> override {\n        visitor.visit(*<\/span>this<\/span>);\n    }\n};\n\nclass<\/span> Engine<\/span>:<\/span> public<\/span> CarElement {\n public:<\/span>\n    void<\/span> accept(CarElementVisitor&<\/span> visitor) const<\/span> override {\n        visitor.visit(*<\/span>this<\/span>);\n    }\n};\n\nclass<\/span> Car<\/span>:<\/span> public<\/span> CarElement {\n public:<\/span>\n    Car(std::<\/span>initializer_list<<\/span>CarElement*><\/span> carElements ):<\/span>\n      elements{carElements} {}\n   \n    void<\/span> accept(CarElementVisitor&<\/span> visitor) const<\/span> override {\n        for<\/span> (auto<\/span> elem :<\/span> elements) {\n            elem-><\/span>accept(visitor);\n        }\n        visitor.visit(*<\/span>this<\/span>);\n    }\n private:<\/span>\n    std::<\/span>vector<<\/span>CarElement*><\/span> elements;                   \/\/ (7)<\/span>\n};\n\nclass<\/span> CarElementDoVisitor<\/span>:<\/span> public<\/span> CarElementVisitor {\n   \n    void<\/span> visit(Body body) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Moving my body"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n\n     void<\/span> visit(Car car) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Starting my car"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n\n    void<\/span> visit(Wheel wheel) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Kicking my "<\/span> <<<\/span> wheel.getName() \n          <<<\/span> " wheel"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n\n    void<\/span> visit(Engine engine) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Starting my engine"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n};\n\nclass<\/span> CarElementPrintVisitor<\/span>:<\/span> public<\/span> CarElementVisitor {\n   \n    void<\/span> visit(Body body) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Visiting body"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n\n     void<\/span> visit(Car car) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Visiting car"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n\n    void<\/span> visit(Wheel wheel) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Visiting "<\/span> <<<\/span> wheel.getName() \n          <<<\/span> " wheel"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n\n    void<\/span> visit(Engine engine) const<\/span> override {\n        std::<\/span>cout <<<\/span> "Visiting engine"<\/span> <<<\/span> '\\n'<\/span>;\n    }\n};\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    Wheel wheelFrontLeft("front left"<\/span>);        \n    Wheel wheelFrontRight("front right"<\/span>);\n    Wheel wheelBackLeft("back left"<\/span>);\n    Wheel wheelBackRight("back right"<\/span>);\n    Body body;\n    Engine engine;\n    Car car {&<\/span>wheelFrontLeft, &<\/span>wheelFrontRight, \n             &<\/span>wheelBackLeft, &<\/span>wheelBackRight,\n             &<\/span>body, &<\/span>engine};\n\n    CarElementPrintVisitor carElementPrintVisitor; \n\n    engine.accept(carElementPrintVisitor);       \/\/ (1)      <\/span>\n    car.accept(carElementPrintVisitor);          \/\/ (2)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    CarElementDoVisitor carElementDoVisitor;\n\n    engine.accept(carElementDoVisitor);          \/\/ (3)<\/span>\n    car.accept(carElementDoVisitor);             \/\/ (4)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
All the car<\/code>‘s components are created at the beginning of the main function. After that, the engine<\/code> and the car<\/code> take the carElementPrintVisitor<\/code> (1 and 2). In lines (3) and (4), both objects are accepted by carElementDoVisitor<\/code>. CarElement<\/code> (5) and CarElementVisitor<\/code> (6) are the abstract base classes of the object and operation hierarchies. The car<\/code> is the most interesting component because it holds its components in a std::vector<element*><\/code> (7). The crucial observation of the visitor pattern is that it depends on two objects, which operation is performed: the visitor and the visited object.<\/p>\n\n\n\n
Here is the output of the program:<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
You will find more information on the Visitor Pattern in my previous post: The Visitor Pattern<\/a>. Admittedly, the Visitor Pattern is very resistant to understanding. Thanks to the overload pattern, this changes with C++23.<\/p>\n\n\n\n
The Overload Pattern<\/h3>\n\n\n\n
The Overload Pattern<\/a> is the modern C++ version of the Visitor Pattern. It combines variadic templates with std:variant <\/a><\/code>and its function std::visit<\/code>.<\/p>\n\n\n\n
Thanks to deducing this in C++23, a lambda expression can explicitly refer to its implicit lambda object.<\/p>\n\n\n\n
\/\/ visitOverload.cpp<\/span>\n\n#include <iostream><\/span>\n#include <string><\/span>\n#include <vector><\/span>\n#include <variant><\/span>\n\ntemplate<\/span><<\/span>class... Ts><\/span> struct<\/span> overloaded :<\/span> Ts... { \n    using<\/span> Ts::<\/span>operator<\/span>()...; \n};\n\nclass<\/span> Wheel<\/span> {\n public:<\/span>\n    Wheel(const<\/span> std::<\/span>string&<\/span> n):<\/span> name(n) { }\n    std::<\/span>string getName() const<\/span> {\n        return<\/span> name;\n    }\n private:<\/span>\n    std::<\/span>string name;\n};\n\nclass<\/span> Body<\/span> {};\n\nclass<\/span> Engine<\/span> {};\n\nclass<\/span> Car<\/span>;\n\nusing<\/span> CarElement =<\/span> std::<\/span>variant<<\/span>Wheel, Body, Engine, Car><\/span>;\n\nclass<\/span> Car<\/span> {\n public:<\/span>\n    Car(std::<\/span>initializer_list<<\/span>CarElement*><\/span> carElements ):<\/span>\n      elements{carElements} {}\n   \n   template<\/span><<\/span>typename<\/span> T><\/span> \n   void<\/span> visitCarElements(T&&<\/span> visitor) const<\/span> {\n       for<\/span> (auto<\/span> elem :<\/span> elements) {\n           std::<\/span>visit(visitor, *<\/span>elem);\n       }\n   }\n private:<\/span>\n    std::<\/span>vector<<\/span>CarElement*><\/span> elements;\n};\n\noverloaded carElementPrintVisitor {                                            \/\/ (2)<\/span>\n    [](const<\/span> Body&<\/span> body)     {  std::<\/span>cout <<<\/span> "Visiting body"<\/span> <<<\/span> '\\n'<\/span>; },      \n    [](this<\/span> auto<\/span> const<\/span>&<\/span> self, const<\/span> Car&<\/span> car)  {  car.visitCarElements(self);  \/\/ (4)<\/span>\n                                                  std::<\/span>cout <<<\/span> "Visiting car"<\/span> <<<\/span> '\\n'<\/span>; },\n    [](const<\/span> Wheel&<\/span> wheel)   {  std::<\/span>cout <<<\/span> "Visiting "<\/span> \n                                          <<<\/span> wheel.getName() <<<\/span> " wheel"<\/span> <<<\/span> '\\n'<\/span>; },\n    [](const<\/span> Engine&<\/span> engine) {  std::<\/span>cout <<<\/span> "Visiting engine"<\/span> <<<\/span> '\\n'<\/span>;}\n};\n\noverloaded carElementDoVisitor {                                               \/\/ (3)<\/span>\n    [](const<\/span> Body&<\/span> body)     {  std::<\/span>cout <<<\/span> "Moving my body"<\/span> <<<\/span> '\\n'<\/span>; },\n    [](this<\/span> auto<\/span> const<\/span>&<\/span> self, const<\/span> Car&<\/span> car) {  car.visitCarElements(self);   \/\/ (5)<\/span>\n                                                std::<\/span>cout <<<\/span> "Starting my car"<\/span> <<<\/span> '\\n'<\/span>; },\n    [](const<\/span> Wheel&<\/span> wheel)   {  std::<\/span>cout <<<\/span> "Kicking my "<\/span> \n                                          <<<\/span> wheel.getName()  <<<\/span> " wheel"<\/span> <<<\/span> '\\n'<\/span>; },\n    [](const<\/span> Engine&<\/span> engine) {  std::<\/span>cout <<<\/span> "Starting my engine"<\/span> <<<\/span> '\\n'<\/span>;}\n};\n \n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    CarElement wheelFrontLeft  =<\/span> Wheel("front left"<\/span>);        \n    CarElement wheelFrontRight =<\/span> Wheel("front right"<\/span>);\n    CarElement wheelBackLeft   =<\/span> Wheel("back left"<\/span>);\n    CarElement wheelBackRight  =<\/span> Wheel("back right"<\/span>);\n    CarElement body            =<\/span> Body{};\n    CarElement engine          =<\/span> Engine{};\n \n    CarElement car  =<\/span> Car{&<\/span>wheelFrontLeft, &<\/span>wheelFrontRight,                    \/\/ (1)<\/span>\n             &<\/span>wheelBackLeft, &<\/span>wheelBackRight,\n             &<\/span>body, &<\/span>engine};\n\n    std::<\/span>visit(carElementPrintVisitor, engine);\n    std::<\/span>visit(carElementPrintVisitor, car);\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>visit(carElementDoVisitor, engine);\n    std::<\/span>visit(carElementDoVisitor, car);\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n}\n<\/pre><\/div>\n\n\n\n
The Car<\/code> (1) represents the object hierarchy, and the two operations carElementPrintVisitor<\/code> (2) and carElementDoVistor<\/code> (3) represent the visitors. The lambda expressions in lines (4) and (5) that visit the car<\/code> can reference the implicit lambda object and thus visit the concrete components of the car: car.visitCarElement(self)<\/code>. The output of the previous program vistitor.cpp<\/code> and this program are identical.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
What’s Next?<\/h2>\n\n\n\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. Thanks to deducing this, we can remove the C and R from the abbreviation.<\/p>\n","protected":false},"excerpt":{"rendered":"
Anyone who thinks a small C++ standard follows a significant C++ standard is wrong. C++23 provides powerful extensions to C++20. These extensions include the core language, particularly the standard library. Today, I present a small but very impactful feature of the core language: deducing this. Deducing this, sometimes also called explicit object parameter, allows it […]<\/p>\n","protected":false},"author":21,"featured_media":7643,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[378],"tags":[],"class_list":["post-7642","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-23"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7642","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=7642"}],"version-history":[{"count":5,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7642\/revisions"}],"predecessor-version":[{"id":8037,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7642\/revisions\/8037"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/7643"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=7642"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=7642"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=7642"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}