{"id":53,"date":"2020-01-18T11:44:44","date_gmt":"2020-01-18T09:44:44","guid":{"rendered":"http:\/\/www.juustila.com\/antti\/?p=53"},"modified":"2020-01-18T12:10:16","modified_gmt":"2020-01-18T10:10:16","slug":"adopting-some-newer-c-features","status":"publish","type":"post","link":"https:\/\/www.juustila.com\/antti\/2020\/01\/18\/adopting-some-newer-c-features\/","title":{"rendered":"Adopting some newer C++ features"},"content":{"rendered":"

I’ve been continuously updating my skills in C++, adopting features from newer features of the language, like from the version C++17. For fun and learning, I’ve been updating some older apps to use these newer features, and implementing some new tools adopting newer features like std::variant, algorithms (instead of traditional loops) and attributes. Some examples below.<\/p>\n

Attributes<\/h3>\n

Instead of commenting in a switch\/case structure that fallthrough is OK<\/a>, use the [[fallthrough]] attribute:<\/p>\n\n\n

      switch<\/span> (argc)<\/span> {<\/span>\n         case<\/span> 4<\/span>:\n            outputFileName<\/span> =<\/span> argv[<\/span>3<\/span>];<\/span>\n            [[fallthrough]];<\/span>\n            \n         case<\/span> 3<\/span>:\n<\/pre><\/div>\n\n\n\n
Reader is then aware that the missing break; is not actually missing by accident, but intentional. Improves code readability and quality, and silences the compiler warning about the missing break.<\/p>\n\n\n\n
To make sure the caller of the function handles the return value, use the [[nodiscard]] attribute:<\/p>\n\n\n\n
[[nodiscard]]<\/span>\nint<\/span> readFile(<\/span>const<\/span> std::string<\/span> &<\/span> fileName,<\/span> std::vector<std::string><\/span> &<\/span> entries);<\/span>\n<\/pre><\/div>\n\n\n\n
Compiler will warn you that the return value is not handled. This again improves code quality.<\/p>\n\n\n\n
\"\"
nodiscard attribute warns you that essential return value is not handled.<\/figcaption><\/figure>\n\n\n\n
Using using instead of typedef<\/h3>\n\n\n\n
I wanted to use a shorter name for a complex data structure. Usually done with typedef<\/code>. Instead, using the using<\/code> keyword, the one used usually with namespaces, is neat:<\/p>\n\n\n\n
using<\/span> queue_package_type<\/span> =<\/span> std::map<std::string,<\/span> std::pair<<\/span>int<\/span>,<\/span>int<\/span>>>;<\/span>\nqueue_package_type<\/span> queuePackageCounts;<\/span>\n<\/pre><\/div>\n\n\n\n
Or similarily:<\/p>\n\n\n\n
using<\/span> NodeContainer<\/span> =<\/span> std::vector<NodeView>;<\/span>\nNodeContainer<\/span> nodes;<\/span>\n\/\/ ...<\/span>\nSPConfigurator::NodeContainer<\/span> nodes<\/span> =<\/span> configurator->getNodes();<\/span>\nstd::for_each(std::begin(nodes),<\/span> std::end(nodes),<\/span> [<\/span>this<\/span>](<\/span>const<\/span> NodeView<\/span> &<\/span> node)<\/span> {<\/span>\n   std::string<\/span> description<\/span> =<\/span> node.getInputAddressWithPort()<\/span> +<\/span> \"\\t\"<\/span> +<\/span> node.getName()<\/span> +<\/span> \"\\t\"<\/span> +<\/span> node.getOutputAddressWithPort();<\/span>\n   QString<\/span> logEntry<\/span> =<\/span> QString::fromStdString(description);<\/span>\n   ui->LogView->appendPlainText(logEntry);<\/span>\n});<\/span>\n<\/pre><\/div>\n\n\n\n
Small thing but makes better looking code, in my opinion. When working with templates, The alias declaration with using<\/code> is compatible with templates, whereas the C style typedef is not<\/a>.<\/p>\n\n\n\n
Algorithms<\/h3>\n\n\n\n
In a recent post<\/a>, I mentioned algorithms like std::iota<\/code> and std::shuffle<\/code>, useful in generating test data. When handling containers (vectors, lists), the “old way” is to use either indexes or iterators to handle the items. Implementing these carelessly may lead to bugs. The better alternative is to use algorithms from the standard library, readily developed and rigorously tested, also considering performance. An example from a small tool app I recently made, which searches if id values read from one file are contained in lines read from another file:<\/p>\n\n\n\n
std::for_each(std::begin(indexes),<\/span> std::end(indexes),<\/span> [&matchCount,<\/span> &dataEntries,<\/span> &output](<\/span>const<\/span> std::string<\/span> &<\/span> index)<\/span> {<\/span>\n   std::any_of(std::begin(dataEntries),<\/span> std::end(dataEntries),<\/span> [&matchCount,<\/span> &index,<\/span> &output](<\/span>const<\/span> std::string<\/span> &<\/span> dataEntry)<\/span> {<\/span>\n      if<\/span> (dataEntry.find(index)<\/span> !=<\/span> std::string::npos)<\/span> {<\/span>\n         *output<\/span> <<<\/span> matchCount+<\/span>1<\/span> <<<\/span> \"   \"<\/span> <<<\/span> dataEntry<\/span> <<<\/span> std::endl;<\/span>\n         matchCount++;<\/span>\n         return<\/span> true;<\/span> \/\/ Not returning from the app but from the lambda function.<\/span>\n      }<\/span>\n      return<\/span> false;<\/span>   \/\/ Not returning from the app but from the lambda function.<\/span>\n   });<\/span>\n});<\/span>\n<\/pre><\/div>\n\n\n\n
std::for_each<\/code> replaces loops created by using iterators (or indexes to the container), and when some additional logic is needed, std::any_of<\/code> is a nice solution to end the search when a match is found. <\/p>\n\n\n\n
A bit more complicated example, using std::find_if<\/code>, std::all_of<\/code> and a boolean predicate object assisting in the search when calling std::find_if<\/code>. In this example (full source code is here<\/a>), there is a composite design pattern implemented for handling hierarchical key-value -pairs. The code sample below implements removing a specific key-value pair from the object hierarchy.<\/p>\n\n\n\n
\/**<\/span>\n A helper struct to assist in finding an Entity with a given name. Used<\/span>\n in EntityComposite::remove(const std::string &) to find an Entity with a given name.<\/span>\n *\/<\/span>\nstruct<\/span> ElementNameMatches<\/span> {<\/span>\n   ElementNameMatches(<\/span>const<\/span> std::pair<std::string,std::string><\/span> &<\/span> nameValue)<\/span> {<\/span>\n      searchNameValue<\/span> =<\/span> nameValue;<\/span>\n   }<\/span>\n   std::pair<std::string,std::string><\/span> searchNameValue;<\/span>\n   bool<\/span> operator<\/span>()<\/span> (<\/span>const<\/span> Entity<\/span> *<\/span> e)<\/span> {<\/span>\n      return<\/span> (e->getName()<\/span> ==<\/span> searchNameValue.first<\/span> &&<\/span> e->getValue()<\/span> ==<\/span> searchNameValue.second);<\/span>\n   }<\/span>\n};<\/span>\n\n\/**<\/span>\n Removes and deletes a child entity from this Entity.<\/span>\n If the child is not an immediate child of this entity, then it is given<\/span>\n to the children to be removed from there, if it is found.<\/span>\n If the child is a Composite, removes and deletes the children too.<\/span>\n @param nameValue A child with the equal name and value properties to remove from this entity.<\/span>\n @return Returns true if the entity was removed, otherwise false.<\/span>\n *\/<\/span>\nbool<\/span> EntityComposite::remove(<\/span>const<\/span> std::pair<std::string,std::string><\/span> &<\/span> nameValue)<\/span> {<\/span>\n   bool<\/span> returnValue<\/span> =<\/span> false;<\/span>\n   auto<\/span> iter<\/span> =<\/span> std::find_if(children.begin(),<\/span> children.end(),<\/span> ElementNameMatches(nameValue));<\/span>\n   if<\/span> (iter<\/span> !=<\/span> children.end())<\/span> {<\/span>\n      Entity<\/span> *<\/span> entity<\/span> =<\/span> *iter;<\/span>\n      children.remove(*iter);<\/span>\n      delete<\/span> entity;<\/span>\n      returnValue<\/span> =<\/span> true;<\/span>\n   }<\/span> else<\/span> {<\/span>\n      \/\/ child was not an immediate child. Check if one of the children (or their child) has the child.<\/span>\n      \/\/ Use a lambda function to go through the children to find and delete the child.<\/span>\n      \/\/ std::all_of can be stopped when the child is found by returning false from the lambda.<\/span>\n      std::all_of(children.begin(),<\/span> children.end(),<\/span> [nameValue,<\/span> &returnValue](Entity<\/span> *<\/span> entity)<\/span> {<\/span>\n         if<\/span> (entity->remove(nameValue))<\/span> {<\/span>\n            returnValue<\/span> =<\/span> true;<\/span>\n            return<\/span> false;<\/span>\n         }<\/span> else<\/span> {<\/span>\n            return<\/span> true;<\/span>\n         }<\/span>\n      });<\/span>\n   }<\/span>\n   return<\/span> returnValue;<\/span>\n}<\/span>\n\n\/\/ And then call remove() like this, for example, with <\/span>\n\/\/ key \"customer\", and value \"Antti Juustila\":<\/span>\nnewComposite->remove({<\/span>\"customer\"<\/span>,<\/span> \"Antti Juustila\"<\/span>});<\/span>\n<\/pre><\/div>\n\n\n\n
What you get is more robust code without your own bugs implemented in “custom” loops with indexes and iterators.<\/p>\n\n\n\n
std::variant from C++17<\/h3>\n\n\n\n
What if your app has some data that can be manipulated in two formats? For example, first you get the data from the network in JSON, and then later you parse the JSON string and create an application specific object holding that parsed data. Later on, you again export the data from the internal object type to JSON to be send over to the network. <\/p>\n\n\n\n
You could implement this so that you have both the JSON\/string object and<\/em> the application internal class object in memory. Then just add logic to know which currently has the data and should be used, and ignore the other variable until it is needed. An alternative is to use the good old union<\/a><\/code> to handle this, if you want to save memory. This could be quite complicated to implement<\/a>.<\/p>\n\n\n\n
C++17 provides a more well managed option — std::<\/code>variant<\/code><\/a>. When using union, you have to keep track what the union contains, but using the variant, it knows which type of object it is currently holding and you can check that. <\/p>\n\n\n\n
Following the scenario above, a class could have a member variable holding the JSON in a string, or<\/em> alternatively, after parsing it, in an application specific object, within an unique pointer assisting with memory management:<\/p>\n\n\n\n
std::variant<std::string,<\/span> std::unique_ptr<DataItem>><\/span> payload;<\/span>\n<\/pre><\/div>\n\n\n\n
In the class containing the payload member variable, you can initialise it to an empty string:<\/p>\n\n\n\n
Package::Package()<\/span>\n:<\/span> payload(<\/span>\"\"<\/span>)<\/span>\n<\/pre><\/div>\n\n\n\n
Then you can provide setters to change from one representation of the data to another:<\/p>\n\n\n\n
\/\/ Set the data to be a JSON string:<\/span>\nvoid<\/span> Package::setPayload(<\/span>const<\/span> std::string<\/span> &<\/span> d)<\/span> {<\/span>\n   payload<\/span> =<\/span> d;<\/span>\n}<\/span>\n\/\/ ...or a DataItem object, parsed from the string:<\/span>\nvoid<\/span> Package::setPayload(std::unique_ptr<DataItem><\/span> item)<\/span> {<\/span>\n   payload<\/span> =<\/span> std::move(item);<\/span>\n}<\/span>\n<\/pre><\/div>\n\n\n\n
When you access the data to use it somewhere, you can check what is actually stored in the variant and return it. If the representation is not the one requested, return an empty value or null pointer to indicate to the caller that the requested representation of the data is not available currently:<\/p>\n\n\n\n
\/\/ Get the string, using std::get_if:<\/span>\nconst<\/span> std::string<\/span> &<\/span> Package::getPayloadString()<\/span> const<\/span> {<\/span>\n   auto<\/span> item<\/span> =<\/span> std::get_if<std::string>(&payload);<\/span>\n   if<\/span> (item)<\/span> {<\/span>\n      return<\/span> *item;<\/span>\n   }<\/span>\n   return<\/span> emptyString;<\/span>\n}<\/span>\n\/\/ Get the DataItem, using std::get_if<\/span>\nconst<\/span> DataItem<\/span> *<\/span> Package::getPayloadObject()<\/span> const<\/span> {<\/span>\n   auto<\/span> item<\/span> =<\/span> std::get_if<std::unique_ptr<DataItem>>(&payload);<\/span>\n   if<\/span> (item)<\/span> {<\/span>\n      return<\/span> item->get();<\/span>\n   }<\/span>\n   return<\/span> nullptr;<\/span>\n}<\/span>\n<\/pre><\/div>\n\n\n\n
Next I’d like to take a look at how to use the new async programming features of C++, as well as the Boost asio library…<\/p>\n","protected":false},"excerpt":{"rendered":"
I’ve been continuously updating my skills in C++, adopting features from newer features of the language, like from the version C++17. For fun and learning, I’ve been updating some older apps to use these newer features, and implementing some new tools adopting newer features like std::variant, algorithms (instead of traditional loops) and attributes. Some examples … Continue reading “Adopting some newer C++ features”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[2],"tags":[27,10,11,28],"class_list":["post-53","post","type-post","status-publish","format-standard","hentry","category-coding","tag-attributes","tag-c","tag-cstd","tag-stdvariant"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/posts\/53","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/comments?post=53"}],"version-history":[{"count":5,"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/posts\/53\/revisions"}],"predecessor-version":[{"id":75,"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/posts\/53\/revisions\/75"}],"wp:attachment":[{"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/media?parent=53"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/categories?post=53"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.juustila.com\/antti\/wp-json\/wp\/v2\/tags?post=53"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}