{"id":5402,"date":"2018-03-09T17:01:47","date_gmt":"2018-03-09T17:01:47","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-more-about-control-structures\/"},"modified":"2023-06-26T11:55:09","modified_gmt":"2023-06-26T11:55:09","slug":"c-core-guidelines-more-about-control-structures","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-more-about-control-structures\/","title":{"rendered":"C++ Core Guidelines: More about Control Structures"},"content":{"rendered":"

My last German post C++ Core Guidelines: To Switch or not to Switch, that is the Question<\/a> got a lot of attention. To use a hash table instead of a switch statement seems to be a highly emotional topic. So I change my original plan. Today, I will present different kinds of control structures. I will start with the if and switch statements, continue with the hash table, and end with dynamic and static polymorphism. Additionally, I will mark a few remarks about performance and maintainability. <\/p>\n

<\/p>\n

 \"640px<\/p>\n

The classical control structure is the if statement; this is my starting point.<\/p>\n

if statement<\/h3>\n

Here is the simple program that I will implement with different control structures.<\/p>\n

\n
\/\/ dispatchIf.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n\r\nenum<\/span> class<\/span> MessageSeverity<\/span>{                                 \/\/ (2)<\/span>\r\n    information,\r\n    warning,\r\n    fatal,\r\n};\r\n\r\nauto<\/span> start =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();              \/\/ (4)<\/span>\r\n\r\nvoid<\/span> writeElapsedTime<\/span>(){                                   \r\n    auto<\/span> now =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();            \/\/ (5)<\/span>\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\nvoid<\/span> writeInformation<\/span>(){ std::<\/span>cerr <<<\/span> \"information\"<\/span> <<<\/span> std::<\/span>endl; }\r\nvoid<\/span> writeWarning<\/span>(){ std::<\/span>cerr <<<\/span> \"warning\"<\/span> <<<\/span> std::<\/span>endl; }\r\nvoid<\/span> writeUnexpected<\/span>(){ std::<\/span>cerr <<<\/span> \"unexpected\"<\/span> <<<\/span> std::<\/span>endl; }\r\n\r\nvoid<\/span> writeMessage<\/span>(MessageSeverity messServer){               \/\/ (1)<\/span>\r\n\t\r\n    writeElapsedTime();                                      \/\/ (3)<\/span>\r\n\t\r\n    if<\/span> (MessageSeverity::<\/span>information ==<\/span> messServer){\r\n\t    writeInformation();\r\n    }\r\n    else<\/span> if<\/span> (MessageSeverity::<\/span>warning ==<\/span> messServer){\r\n\t    writeWarning();\r\n    }\r\n    else<\/span>{\r\n\t    writeUnexpected();\r\n    }\r\n  \r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n  \r\n    writeMessage(MessageSeverity::<\/span>information);\r\n    writeMessage(MessageSeverity::<\/span>warning);\r\n    writeMessage(MessageSeverity::<\/span>fatal);\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The function writeMessage<\/span> in line (1)  displays the elapsed time in seconds (3) since the program’s start and a log message. It uses an enumeration (2) for the message severity. I use the start time (4) and the actual time (5) to calculate the elapsed time. As the name suggested, the std::steady_clock <\/span>cannot be adjusted; therefore, it is the right choice for this measurement. The key part of the program is part of the function writeMessage<\/span> (1), in which I decide which message should be displayed. In this case, I used if-else statements. <\/p>\n
To make it right, I had to look up the syntax for the if-else statement. <\/p>\n
Here is the output of the program:<\/p>\n
 \"dispatchIf\"<\/p>\n
 I will skip the output for the remaining examples. Besides the numbers, it is always the same.<\/p>\n<\/p>\n
switch statement<\/h3>\n
The following program is quite similar to the previous one. Only the implementation of the function writeMessage<\/span> changed. <\/p>\n
\n
\/\/ dispatchSwitch.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n\r\nenum<\/span> class<\/span> MessageSeverity<\/span>{\r\n    information,\r\n    warning,\r\n    fatal,\r\n};\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\nvoid<\/span> writeInformation<\/span>(){ std::<\/span>cerr <<<\/span> \"information\"<\/span> <<<\/span> std::<\/span>endl; }\r\nvoid<\/span> writeWarning<\/span>(){ std::<\/span>cerr <<<\/span> \"warning\"<\/span> <<<\/span> std::<\/span>endl; }\r\nvoid<\/span> writeUnexpected<\/span>(){ std::<\/span>cerr <<<\/span> \"unexpected\"<\/span> <<<\/span> std::<\/span>endl; }\r\n\r\nvoid<\/span> writeMessage<\/span>(MessageSeverity messSever){\r\n\t\r\n    writeElapsedTime();\r\n\r\n    switch<\/span>(messSever){\r\n        case<\/span> MessageSeverity::<\/span>information:<\/span>\r\n            writeInformation();\r\n            break<\/span>;\r\n        case<\/span> MessageSeverity::<\/span>warning:<\/span>\r\n            writeWarning();\r\n            break<\/span>;\r\n        default:<\/span>\r\n            writeUnexpected();\r\n            break<\/span>;\r\n  }\r\n  \r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n  \r\n    writeMessage(MessageSeverity::<\/span>information);\r\n    writeMessage(MessageSeverity::<\/span>warning);\r\n    writeMessage(MessageSeverity::<\/span>fatal);\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I will make it short. Let’s continue with the hash table.<\/p>\n
Hashtable<\/h3>\n
For a more elaborate discussion of the switch statement and the hash table, read my last post: C++ Core Guidelines: To Switch or not to Switch, that is the Question<\/a>.<\/p>\n
 <\/p>\n
\n
\/\/ dispatchHashtable.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n#include <unordered_map><\/span>\r\n\r\nenum<\/span> class<\/span> MessageSeverity<\/span>{\r\n  information,\r\n  warning,\r\n  fatal,\r\n};\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\nvoid<\/span> writeInformation<\/span>(){ std::<\/span>cerr <<<\/span> \"information\"<\/span> <<<\/span> std::<\/span>endl; }\r\nvoid<\/span> writeWarning<\/span>(){ std::<\/span>cerr <<<\/span> \"warning\"<\/span> <<<\/span> std::<\/span>endl; }\r\nvoid<\/span> writeUnexpected<\/span>(){ std::<\/span>cerr <<<\/span> \"unexpected\"<\/span> <<<\/span> std::<\/span>endl; }\r\n\r\nstd::<\/span>unordered_map<<\/span>MessageSeverity, std::<\/span>function<<\/span>void<\/span>()>><\/span> mess2Func{\r\n    {MessageSeverity::<\/span>information, writeInformation},\r\n    {MessageSeverity::<\/span>warning, writeWarning},\r\n    {MessageSeverity::<\/span>fatal, writeUnexpected}\r\n};\r\n\r\nvoid<\/span> writeMessage<\/span>(MessageSeverity messServer){\r\n\t\r\n\twriteElapsedTime();\r\n\t\r\n\tmess2Func[messServer]();\r\n\t\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n  \r\n  writeMessage(MessageSeverity::<\/span>information);\r\n  writeMessage(MessageSeverity::<\/span>warning);\r\n  writeMessage(MessageSeverity::<\/span>fatal);\r\n\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Is this the end? No? In C++, we have dynamic and static polymorphism, as a few of my readers mentioned in their discussion. With the if-else or the switch statement, I used an enumerator to dispatch the correct case. The key of my hash table behaves similarly. <\/p>\n
Dynamic or static polymorphism is different. Instead of an enumerator or a key for dispatching the right action, I use objects which decide autonomously at runtime (dynamic polymorphism) or compile-time (static polymorphism) what should be done. <\/p>\n
Let’s continue with dynamic polymorphism.<\/p>\n
Dynamic polymorphism<\/h3>\n
Not, the decision logic is encoded in the type hierarchy.<\/p>\n
\n
\/\/ dispatchDynamicPolymorphism.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\nstruct<\/span> MessageSeverity{                         \/\/ (1)<\/span>\r\n\tvirtual<\/span> void<\/span> writeMessage() const<\/span> {\r\n\t\tstd::<\/span>cerr <<<\/span> \"unexpected\"<\/span> <<<\/span> std::<\/span>endl;\r\n\t}\r\n};\r\n\r\nstruct<\/span> MessageInformation:<\/span> MessageSeverity{     \/\/ (2)<\/span>\r\n\tvoid<\/span> writeMessage() const<\/span> override {\r\n\t\tstd::<\/span>cerr <<<\/span> \"information\"<\/span> <<<\/span> std::<\/span>endl;\r\n\t}\r\n};\r\n\r\nstruct<\/span> MessageWarning:<\/span> MessageSeverity{         \/\/ (3)<\/span>\r\n\tvoid<\/span> writeMessage() const<\/span> override {\r\n\t\tstd::<\/span>cerr <<<\/span> \"warning\"<\/span> <<<\/span> std::<\/span>endl;\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){\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){\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> std::<\/span>endl;\r\n  \r\n    MessageInformation messInfo;\r\n    MessageWarning messWarn;\r\n    MessageFatal messFatal;\r\n  \r\n    MessageSeverity&<\/span> messRef1 =<\/span> messInfo;            \r\n    MessageSeverity&<\/span> messRef2 =<\/span> messWarn;\r\n    MessageSeverity&<\/span> messRef3 =<\/span> messFatal;\r\n  \r\n    writeMessageReference(messRef1);              \/\/ (4)<\/span>\r\n    writeMessageReference(messRef2);\r\n    writeMessageReference(messRef3);\r\n  \r\n    std::<\/span>cerr <<<\/span> std::<\/span>endl;\r\n  \r\n    MessageSeverity*<\/span> messPoin1 =<\/span> new<\/span> MessageInformation;\r\n    MessageSeverity*<\/span> messPoin2 =<\/span> new<\/span> MessageWarning;\r\n    MessageSeverity*<\/span> messPoin3 =<\/span> new<\/span> MessageFatal;\r\n  \r\n    writeMessagePointer(messPoin1);               \/\/ (5)<\/span>\r\n    writeMessagePointer(messPoin2);\r\n    writeMessagePointer(messPoin3);\r\n  \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The classes (1), (2), and (3) know what they have to display if used. The key idea is that the static type MessageSeverity<\/span> differs from the dynamic type such as MessageInformation<\/span>(4); therefore, the late binding will kick in, and the writeMessage<\/span> methods (5), (6), and (7) of the dynamic types are used. Dynamic polymorphism requires a kind of indirection. You can use references (8) or pointers (9). <\/p>\n
From a performance perspective, we can do better and make the dispatch at compile time.<\/p>\n
Static polymorphism  <\/h3>\n
Static polymorphism is often called CRTP. CRTP stands for the C++ idiom C<\/strong>uriously R<\/b>ecurring T<\/b>emplate P<\/b>attern. Curiously because a class derives this technique from a class template instantiation using itself as a template argument.<\/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 (3), (4), and (5) derive from the base class MessageSeverity<\/span>. The method writeMessage<\/span> is a kind of interface that dispatches to the concrete implementations writeMessageImplementation<\/span>.  To make that happen, the object will be upcasted to the ConcreteMessage<\/span>:  static_cast<ConcreteMessage*>(this)->writeMessageImplementation();. <\/span>This is the static dispatch at compile time; therefore, this technique is called static polymorphism.<\/p>\n
It took me time to get used to it, but applying the static polymorphism in line (6) is quite easy. If the curiously recurring template pattern is still curious to you, I wrote an article about it: C++ is Lazy: CRTP<\/a><\/p>\n
To end my comparison, let me compare these various techniques.<\/p>\n
My simple comparison<\/h2>\n
Let’s first look at your preferred way to implement and maintain a control structure. Depending on your experience as a C programmer, the if or switch statements seem pretty natural to you. If you have an interpreter background, you may prefer the hash table. With an object orientation background, dynamic polymorphism is your preferred way to implement the control structure. Static polymorphism, also called CRTP, is quite unique; therefore, it will take some time to get comfortable with it. Afterward, it is quite a pattern you have to use. <\/p>\n
I must mention the new context-sensitive identifiers override from the security perspective.  It helps to express your intent to override a virtual method in your type hierarchy. If you make it wrong, the compiler will complain. <\/p>\n
Now to the more interesting question. What are the performance differences? I will only provide a rough idea without numbers. If you have a long series of if statements, this will become quite expensive because many comparisons are involved. The dynamic polymorphism and the hash table will be faster and in the same ballpark because, in both cases, a pointer indirection is involved. The switch statement and the static polymorphism make their decision at compile time; therefore, they are the two fastest control structures.<\/p>\n
What’s next?<\/h2>\n
I hope I’m done with the discussion of the different control structures; therefore, I will in my next post<\/a> the last rules to statements and start with the rules for arithmetic expressions.<\/span><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
My last German post C++ Core Guidelines: To Switch or not to Switch, that is the Question got a lot of attention. To use a hash table instead of a switch statement seems to be a highly emotional topic. So I change my original plan. Today, I will present different kinds of control structures. I will start […]<\/p>\n","protected":false},"author":21,"featured_media":5400,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[372],"tags":[472,491,489,490],"class_list":["post-5402","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-modern-c","tag-associative-containers","tag-control-structures","tag-if","tag-switch"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5402","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=5402"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5402\/revisions"}],"predecessor-version":[{"id":6836,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5402\/revisions\/6836"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5400"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5402"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5402"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5402"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}