{"id":6324,"date":"2022-03-13T18:44:44","date_gmt":"2022-03-13T18:44:44","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/policy-and-traits\/"},"modified":"2023-06-26T09:10:56","modified_gmt":"2023-06-26T09:10:56","slug":"policy-and-traits","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/policy-and-traits\/","title":{"rendered":"Policy"},"content":{"rendered":"

Thanks to templates, there are new ways of software design. Policies and traits are two commonly used idioms in C++.<\/p>\n

<\/p>\n

 \"PolicyAndTraits\"<\/p>\n

Policy and traits are often used in one sentence. Let me start with policies.<\/p>\n<\/p>\n

Policy<\/h2>\n

A policy is a generic function or class whose behavior can be configured. Typically, there are default values for the policy parameters. std::vector<\/code> and std::unordered_map<\/code> exemplifies this.<\/p>\n

<\/p>\n

\n
template<\/span><<\/span>class<\/span> T<\/span>, class<\/span> Allocator<\/span> =<\/span> std::<\/span>allocator<<\/span>T>><\/span>          \/\/ (1)<\/span><\/em>\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>,                               \/\/ (3)<\/span><\/em>\r\n    class<\/span> KeyEqual<\/span> =<\/span> std::<\/span>equal_to<<\/span>Key><\/span>,                       \/\/ (4)<\/span><\/em>\r\n    class<\/span> allocator<\/span> =<\/span> std::<\/span>allocator<<\/span>std::<\/span>pair<<\/span>const<\/span> Key, T>><\/span>  \/\/ (2)<\/span><\/em>\r\nclass<\/span> unordered_map<\/span>;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
This means each container has a default allocator for its elements depending on T<\/code> (line 1) or  std::pair<const Key, T><\/code> (line 2). Additionally, std::unorderd_map<\/code> has a default hash function (line 3) and a default equal function (4). The hash function calculates the hash value based on the key, and the equal function deals with collisions in the buckets. My previous post, “Hash Functions<\/a>” gives you more information about std::unordered_map<\/code>.<\/p>\n
Let me use a user-defined data type MyInt<\/code> as a key in a std::unordered_map. <\/code><\/p>\n
<\/p>\n
\n
\/\/ MyIntAsKey.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <unordered_map><\/span>\r\n\r\nstruct<\/span> MyInt{\r\n    explicit<\/span> MyInt(int<\/span> v):<\/span>val(v){}\r\n    int<\/span> val;\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>unordered_map<<\/span>MyInt, int<\/span>><\/span> myMap{ {MyInt(-<\/span>2<\/span>), -<\/span>2<\/span>}, {MyInt(-<\/span>1<\/span>), -<\/span>1<\/span>}, \r\n                                          {MyInt(0<\/span>), 0<\/span>}, {MyInt(1<\/span>), 1<\/span>} };\r\n\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The compilation fails pretty wordily because MyInt<\/code> does not support the hash function or the equal function.<\/p>\n
\"MyIntAsKey\"<\/p>\n
Now, the policy kicks in. You can replace the policy parameters. The following class MyInt<\/code> can, therefore, be used as a key in a std::unordered_map.<\/code><\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ templatesPolicy.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <unordered_map><\/span>\r\n\r\nstruct<\/span> MyInt{\r\n    explicit<\/span> MyInt(int<\/span> v):<\/span>val(v){}\r\n    int<\/span> val;\r\n};\r\n\r\nstruct<\/span> MyHash{                                                        \/\/ (1)<\/span>\r\n    std::<\/span>size_t<\/span> operator<\/span>()(MyInt m) const<\/span> {\r\n        std::<\/span>hash<<\/span>int<\/span>><\/span> hashVal;\r\n        return<\/span> hashVal<\/span>(m.val);\r\n    }\r\n};\r\n\r\nstruct<\/span> MyEqual{\r\n    bool<\/span> operator<\/span> () (const<\/span> MyInt&<\/span> fir, const<\/span> MyInt&<\/span> sec) const<\/span> {      \/\/ (2)<\/span>\r\n        return<\/span> fir.val ==<\/span> sec.val;\r\n    }\r\n};\r\n\r\nstd::<\/span>ostream&<\/span> operator<\/span> <<<\/span> (std::<\/span>ostream&<\/span> strm, const<\/span> MyInt&<\/span> myIn){     \/\/ (3)<\/span>\r\n    strm <<<\/span> \"MyInt(\"<\/span> <<<\/span> myIn.val <<<\/span> \")\"<\/span>;\r\n    return<\/span> strm;\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    typedef<\/span> std::<\/span>unordered_map<<\/span>MyInt, int<\/span>, MyHash, MyEqual><\/span> MyIntMap;  \/\/ (4)<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> \"MyIntMap: \"<\/span>;\r\n    MyIntMap myMap{{MyInt(-<\/span>2<\/span>), -<\/span>2<\/span>}, {MyInt(-<\/span>1<\/span>), -<\/span>1<\/span>}, {MyInt(0<\/span>), 0<\/span>}, {MyInt(1<\/span>), 1<\/span>}};\r\n\r\n    for<\/span>(auto<\/span> m :<\/span> myMap) std::<\/span>cout <<<\/span> '{'<\/span> <<<\/span> m.first <<<\/span> \", \"<\/span> <<<\/span> m.second <<<\/span> \"}\"<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I implemented the hash function (line 1) and the equal function (line 2) as a function object and overloaded, for convenience reasons, the output operator (line 3). Line 4 creates out of all components a new type MyIntMap<\/code> that uses MyInt<\/code> as key. The following screenshot shows the output of the instance myMa<\/code>p.<\/p>\n
\"templatesPolicy\"<\/p>\n
There are two typical ways to implement policies: composition and inheritance.<\/p>\n
Composition<\/h3>\n
The following class Message<\/code> uses composition to configure its output device during compile time.<\/p>\n
<\/p>\n
\n
\/\/ policyComposition.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <fstream><\/span>\r\n#include <string><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> OutputPolicy>                    \/\/ (1)<\/span><\/em><\/span>\r\nclass<\/span> Message<\/span> {\r\n public:<\/span>\r\n    void<\/span> write(const<\/span> std::<\/span>string&<\/span> mess) const<\/span> {\r\n        outPolicy.print(mess);                      \/\/ (2)<\/span><\/em>\r\n    }\r\n private:<\/span>\r\n    OutputPolicy outPolicy;   \r\n};\r\n\r\nclass<\/span> WriteToCout<\/span> {                                 \/\/ (5)<\/span><\/em>\r\n public:<\/span>\r\n    void<\/span> print(const<\/span> std::<\/span>string&<\/span> message) const<\/span> {\r\n        std::<\/span>cout <<<\/span> message <<<\/span> '\\n'<\/span>;\r\n    }\r\n};\r\n\r\nclass<\/span> WriteToFile<\/span> {                                 \/\/ (6)<\/span><\/em>\r\n public:<\/span>\r\n    void<\/span> print(const<\/span> std::<\/span>string&<\/span> message) const<\/span> {\r\n        std::<\/span>ofstream myFile;\r\n        myFile.open(\"policyComposition.txt\"<\/span>);\r\n        myFile <<<\/span> message <<<\/span> '\\n'<\/span>;\r\n    }\r\n};\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    Message<<\/span>WriteToCout><\/span> messageCout;              \/\/ (3)<\/span><\/em>\r\n    messageCout.write(\"Hello world\"<\/span>);\r\n\r\n    Message<<\/span>WriteToFile><\/span> messageFile;              \/\/ (4)<\/span><\/em>\r\n    messageFile.write(\"Hello world\"<\/span>);\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The class Message has the template parameter OutputPolicy (line 1) as policy. A call of its member function write<\/code> delegates directly to its member outPolicy<\/code> (line 2). You can create two different Message<\/code> instances (lines 3 and 4). One writing to count (line 5), and one writing to a file (line 6).<\/p>\n
The screenshot shows the write operation to cout<\/code> and the file policyComposition.txt<\/code>.<\/p>\n
\"policyComposition\"<\/h3>\n
Inheritance<\/h3>\n
The inheritance-based implementation is quite similar to the composite based in the file policyComposition.cpp<\/code>. The main difference is that the composite-based implementation has the policy, but the inheritance-based implementation derives from its policy.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ policyInheritance.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <fstream><\/span>\r\n#include <string><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> OutputPolicy>                  <\/em><\/span><\/span>\r\nclass<\/span> Message<\/span> :<\/span> private<\/span> OutputPolicy {            \/\/ (1) <\/span><\/em>\r\n public:<\/span>\r\n    void<\/span> write(const<\/span> std::<\/span>string&<\/span> mess) const<\/span> {\r\n        print(mess);                              \/\/ (2)<\/span><\/em>\r\n    }\r\n private:<\/span>\r\n    using<\/span> OutputPolicy::<\/span>print;\r\n};\r\n\r\nclass<\/span> WriteToCout<\/span> {\r\n protected:<\/span>\r\n    void<\/span> print(const<\/span> std::<\/span>string&<\/span> message) const<\/span> {\r\n        std::<\/span>cout <<<\/span> message <<<\/span> '\\n'<\/span>;\r\n    }\r\n};\r\n\r\nclass<\/span> WriteToFile<\/span> {\r\n protected:<\/span>\r\n    void<\/span> print(const<\/span> std::<\/span>string&<\/span> message) const<\/span> {\r\n        std::<\/span>ofstream myFile;\r\n        myFile.open(\"policyInheritance.txt\"<\/span>);\r\n        myFile <<<\/span> message <<<\/span> '\\n'<\/span>;\r\n    }\r\n};\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    Message<<\/span>WriteToCout><\/span> messageCout;\r\n    messageCout.write(\"Hello world\"<\/span>);\r\n\r\n    Message<<\/span>WriteToFile><\/span> messageFile;\r\n    messageFile.write(\"Hello world\"<\/span>);\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Instead of the previous implementation of the class Message<\/code>, this one derives from its template parameter privately and introduces the private inherited print<\/code> function into the class scope. I skip the output of the program for obvious reasons. Okay. I hear your question: Should I use composition or inheritance for implementing a policy-based design?<\/p>\n
Composition or Inheritance<\/h3>\n
In general, I prefer composition over inheritance. In general, but for a policy-based design, you should consider inheritance.<\/p>\n
If  OutputPolicy<\/code> is empty, you can benefit from the so-called empty base class optimization<\/a>. Empty means that OutputPolicy<\/code> has no non-static data members and no non-empty base classes. Consequentially OutputPolicy<\/code> does not add anything to the size of Message<\/code>. On the contrary, when Message<\/code> has the member OutputPolicy<\/code>, OutputPolicy<\/code> adds at least one byte to the size of Message<\/code>. My argument may not sound convincing, but often a class uses more than one policy.<\/p>\n
What’s next?<\/h2>\n
Traits are class templates that pull properties out of a generic type. I will write more about them in my next post.<\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Thanks to templates, there are new ways of software design. Policies and traits are two commonly used idioms in C++.<\/p>\n","protected":false},"author":21,"featured_media":6320,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[402],"class_list":["post-6324","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates","tag-policy"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6324","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=6324"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6324\/revisions"}],"predecessor-version":[{"id":6677,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6324\/revisions\/6677"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6320"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6324"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6324"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6324"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}