{"id":6315,"date":"2022-03-02T08:35:29","date_gmt":"2022-03-02T08:35:29","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/mixins\/"},"modified":"2023-06-26T09:11:58","modified_gmt":"2023-06-26T09:11:58","slug":"mixins","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/mixins\/","title":{"rendered":"Mixins"},"content":{"rendered":"

In my previous  post “More about Dynamic and Static Polymorphism”, I used the Curiously Recurring Template Pattern (CRTP) to implement static polymorphism. Another typical use case for CRTP is mixins.<\/p>\n

<\/p>\n

 \"StaticDynamic\"<\/p>\n

Mixins<\/a> are a popular idea in the design of classes to mix in new code. Therefore, it’s an often-used technique in Python to change the behavior of a class by using multiple inheritances. Contrary to C++, it is legal in Python to have more than one method definition in a class hierarchy. Python uses that method that is first in the Method Resolution Order <\/a>(MRO).<\/p>\n

You can implement mixins in C++ by using CRTP. A prominent example is the class std::enable_shared_from_this<\/code>.<\/p>\n

std::enable_shared_from_this<\/code><\/h2>\n

Let’s see std::enable_shared_from<\/code> this and, therefore, CRTP applied.<\/p>\n

 <\/p>\n

<\/p>\n

\n
\/\/ enableShared.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n\r\nclass<\/span> ShareMe<\/span>:<\/span> public<\/span> std::<\/span>enable_shared_from_this<<\/span>ShareMe> <\/span>{  \/\/ (1)<\/span><\/em>\r\npublic:<\/span>\r\n  std::<\/span>shared_ptr<<\/span>ShareMe><\/span> getShared(){\r\n    return<\/span> shared_from_this();                                  \/\/ (2)<\/span><\/em>\r\n  }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n  std::<\/span>shared_ptr<<\/span>ShareMe><\/span> shareMe(new<\/span> ShareMe);\r\n  std::<\/span>shared_ptr<<\/span>ShareMe><\/span> shareMe1=<\/span> shareMe-><\/span>getShared();      \/\/ (3)<\/span><\/em>\r\n  {\r\n    auto<\/span> shareMe2(shareMe1);\r\n    std::<\/span>cout <<<\/span> \"shareMe.use_count(): \"<\/span>  <<<\/span> shareMe.use_count() <<<\/span> '\\n'<\/span>;\r\n  }\r\n  std::<\/span>cout <<<\/span> \"shareMe.use_count(): \"<\/span>  <<<\/span> shareMe.use_count() <<<\/span> '\\n'<\/span>;\r\n  \r\n  shareMe1.reset();\r\n  \r\n  std::<\/span>cout <<<\/span> \"shareMe.use_count(): \"<\/span>  <<<\/span> shareMe.use_count() <<<\/span> '\\n'<\/span>;\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
By using the class, std::enable_shared_from_this<\/code> you can create objects that return a  std::shared_ptr<\/code> to itself. You must derive your class public from (line 1) to get it. Now, your class MySharedClass<\/code> has a member function shared_from_this<\/code> (line 2) for creating std::shared_ptr<\/code> to its objects. The call shareMe->getShared()<\/code> (line 3) creates a new smart pointer. The member function getShared<\/code> internally uses the function shared_from_this<\/code> (line 2). The following screenshot shows the creation of the shared pointer.<\/p>\n
\"enabledShared\"<\/p>\n
 <\/p>\n
How do mixin classes work in C++? Let me introduce a typical use case.<\/p>\n<\/p>\n
Extending a Class with all Relational Operators<\/h2>\n
Imagine you want to implement all six comparison operators for your data type.  (Of course, with C++20, the compiler can auto-generate them:  C++20: The Three-Way Comparison Operator<\/a>). So far, you have only implemented the smaller operator (<). You know that you can derive all other five comparison operators (<=, >, >=, ==<\/code> , and !=<\/code>) from the smaller operator. Applying this idea and using CRTP save you many keyboard strokes.<\/p>\n
<\/p>\n
\n
\/\/ mixins.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Derived><\/span>\r\nstruct<\/span> Relational {\r\n    friend<\/span> bool<\/span> operator<\/span> ><\/span> (Derived const<\/span>&<\/span> op1, Derived const<\/span>&<\/span> op2){\r\n       return<\/span> op2 <<\/span> op1;\r\n    }\r\n    friend<\/span> bool<\/span> operator<\/span> ==<\/span> (Derived const<\/span>&<\/span> op1, Derived const<\/span>&<\/span> op2){\r\n        return<\/span> !<\/span>(op1 <<\/span> op2) &&<\/span> !<\/span>(op2 <<\/span> op1);\r\n    }\r\n    friend<\/span> bool<\/span> operator<\/span> !=<\/span> (Derived const<\/span>&<\/span> op1, Derived const<\/span>&<\/span> op2){\r\n        return<\/span> (op1 <<\/span> op2) ||<\/span> (op2 <<\/span> op1);\r\n    }\r\n    friend<\/span> bool<\/span> operator<\/span> <=<\/span> (Derived const<\/span>&<\/span> op1, Derived const<\/span>&<\/span> op2){ \r\n        return<\/span> (op1 <<\/span> op2) ||<\/span> (op1 ==<\/span> op2);\r\n    }\r\n    friend<\/span> bool<\/span> operator<\/span> >=<\/span> (Derived const<\/span>&<\/span> op1, Derived const<\/span>&<\/span> op2){\r\n        return<\/span> (op1 ><\/span> op2) ||<\/span> (op1 ==<\/span> op2);\r\n    }\r\n};\r\n\r\nclass<\/span> Apple<\/span>:<\/span> public<\/span> Relational<<\/span>Apple><\/span>{\r\npublic:<\/span>\r\n    explicit<\/span> Apple(int<\/span> s):<\/span> size{s}{};\r\n    friend<\/span> bool<\/span> operator<\/span> <<\/span> (Apple const<\/span>&<\/span> a1, Apple const<\/span>&<\/span> a2){    \/\/ (1)<\/span><\/em>\r\n        return<\/span> a1.size <<\/span> a2.size;\r\n    }\r\nprivate:<\/span>\r\n    int<\/span> size;\r\n};\r\n\r\nclass<\/span> Man<\/span>:<\/span> public<\/span> Relational<<\/span>Man><\/span>{                                 \/\/ (3)<\/span><\/em>\r\npublic:<\/span>\r\n    explicit<\/span> Man(const<\/span> std::<\/span>string&<\/span> n):<\/span> name{n}{}\r\n    friend<\/span> bool<\/span> operator<\/span> <<\/span> (Man const<\/span>&<\/span> m1, Man const<\/span>&<\/span> m2){         \/\/ (2)<\/span><\/em>\r\n        return<\/span> m1.name <<\/span> m2.name;\r\n    }\r\nprivate:<\/span>\r\n    std::<\/span>string name;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> '\\n'<\/span>;\r\n  \r\n  Apple apple1{5<\/span>};\r\n  Apple apple2{10<\/span>}; \r\n  std::<\/span>cout <<<\/span> \"apple1 < apple2: \"<\/span> <<<\/span> (apple1 <<\/span> apple2) <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"apple1 > apple2: \"<\/span> <<<\/span> (apple1 ><\/span> apple2) <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"apple1 == apple2: \"<\/span> <<<\/span> (apple1 ==<\/span> apple2) <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"apple1 != apple2: \"<\/span> <<<\/span> (apple1 !=<\/span> apple2) <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"apple1 <= apple2: \"<\/span> <<<\/span> (apple1 <=<\/span> apple2) <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"apple1 >= apple2: \"<\/span> <<<\/span> (apple1 >=<\/span> apple2) <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n  Man man1{\"grimm\"<\/span>};\r\n  Man man2{\"jaud\"<\/span>};\r\n  std::<\/span>cout <<<\/span> \"man1 < man2: \"<\/span> <<<\/span> (man1 <<\/span> man2) <<<\/span> '\\n'<\/span>; \r\n  std::<\/span>cout <<<\/span> \"man1 > man2: \"<\/span> <<<\/span> (man1 ><\/span> man2) <<<\/span> '\\n'<\/span>; \r\n  std::<\/span>cout <<<\/span> \"man1 == man2: \"<\/span> <<<\/span> (man1 ==<\/span> man2) <<<\/span> '\\n'<\/span>; \r\n  std::<\/span>cout <<<\/span> \"man1 != man2: \"<\/span> <<<\/span> (man1 !=<\/span> man2) <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"man1 <= man2: \"<\/span> <<<\/span> (man1 <=<\/span> man2) <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"man1 >= man2: \"<\/span> <<<\/span> (man1 >=<\/span> man2) <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I’ve for Apple<\/code> and Man<\/code> implemented the smaller operator (lines 1 and 2).  For simplicity, I only use the class Man<\/code> in my argumentation.  Man is public<\/code> derived from the class Relational<Man><\/code> (line 3) using CRTP. The class Relational<\/code> supports the five missing relational operators (<=, <,>=, ==<\/code>, and !=<\/code>).  The five relations operators are mapped onto the less operator of Man (line 2). <\/p>\n
\"mixins\"<\/p>\n
Honestly, I like the name mixins for this idiom. The class Relational<\/code> mixes the remaining relational operators into the class Man<\/code>.<\/p>\n
The characteristic of CRTP is that a class Derived<\/code> derives from a class template Base<\/code> and Base<\/code> has Derived<\/code> as a template argument:<\/p>\n
<\/p>\n
\n
class<\/span> Derived<\/span> :<\/span> public<\/span> Base<<\/span>Derived><\/span>      \/\/ (1)<\/span>\r\n{\r\n    ...\r\n};\r\n\r\nclass<\/span> Derivedwrong<\/span> :<\/span> public<\/span> Base<<\/span>Derived><\/span> \/\/ (2)<\/span>\r\n{\r\n    ...\r\n};\r\n<\/pre>\n<\/div>\n
 <\/p>\n
How can you ensure that you are not erroneously derived the wrong class DervivedWrong <\/code>from Base<Derived><\/code> such as in line 2?<\/p>\n
Checked CRTP<\/h2>\n
The trick is straightforward: make the constructor of Base<\/code> private.<\/p>\n
<\/p>\n
\n
\/\/ crtpCheck.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(){\r\n    static_cast<\/span><<\/span>Derived*><\/span>(this<\/span>)-><\/span>implementation();\r\n  }\r\nprivate:<\/span>\r\n    Base() =<\/span> default<\/span>;             \/\/ (2)<\/span><\/em>\r\n    friend<\/span> Derived;               \/\/ (2)<\/span><\/em>\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> '\\n'<\/span>;\r\n  }\r\n};\r\n\r\nstruct<\/span> Derived2:<\/span> Base<<\/span>Derived1><\/span>{   \/\/ (3)<\/span><\/em>\r\n  void<\/span> implementation(){\r\n    std::<\/span>cout <<<\/span> \"Implementation Derived1\"<\/span> <<<\/span> '\\n'<\/span>;\r\n  }\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> execute(T&<\/span> base){\r\n    base.interface();\r\n}\r\n\r\nint<\/span> main(){\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n  Derived1 d1;\r\n  execute(d1);\r\n    \r\n  Derived2 d2;\r\n  execute(d2);\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Base<\/code> has a private default constructor (line 1). Only the class Base<\/code> itself or the friend Derived<\/code> (line 2) can invoke the default constructor. Consequentially, the call Derived2 d2<\/code> (line 3) fails because Derived2<\/code> it is derived from Base<Derived1><\/code>. Here is the error message from GCC:<\/p>\n
\"crtpCheck\"<\/h2>\n
What’s next?<\/h2>\n
The Curiously Recurring Template Pattern (CRTP) is not easy to understand but very powerful. The same holds for expression templates. Expression templates allow you to get rid of superfluous temporaries.<\/p>\n
 <\/p>\n<\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
In my previous  post “More about Dynamic and Static Polymorphism”, I used the Curiously Recurring Template Pattern (CRTP) to implement static polymorphism. Another typical use case for CRTP is mixins.<\/p>\n","protected":false},"author":21,"featured_media":6312,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[426,425],"class_list":["post-6315","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates","tag-crtp","tag-mixins"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6315","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=6315"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6315\/revisions"}],"predecessor-version":[{"id":6679,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6315\/revisions\/6679"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6312"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6315"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6315"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6315"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
To learn more about smart pointers, read my previous posts: smart pointers<\/a>.<\/p>\n