{"id":5995,"date":"2020-09-24T20:36:08","date_gmt":"2020-09-24T20:36:08","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/more-convenience-functions-for-containers-with-c-20\/"},"modified":"2020-09-24T20:36:08","modified_gmt":"2020-09-24T20:36:08","slug":"more-convenience-functions-for-containers-with-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/more-convenience-functions-for-containers-with-c-20\/","title":{"rendered":"More Convenience Functions for Containers with C++20"},"content":{"rendered":"

Removing elements from a container or asking if an associative container has a specific key is too complicated. I should say it was because with C++20, the story changes.<\/p>\n

<\/p>\n

 \"TimelineCpp20CoreLanguage\"<\/p>\n

Let me start simply. You want to erase an element from a container. <\/p>\n

The erase-remove Idiom<\/h2>\n

Okay. Removing an element from a container is quite easy. In the case of a std::vecto<\/code>r you can use the function std::remove. <\/code><\/p>\n

 <\/p>\n

<\/p>\n

\n
\/\/ removeElements.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>vector myVec{-<\/span>2<\/span>, 3<\/span>, -<\/span>5<\/span>, 10<\/span>, 3<\/span>, 0<\/span>, -<\/span>5<\/span> };\r\n\r\n    for<\/span> (auto<\/span> ele:<\/span> myVec) std::<\/span>cout <<<\/span> ele <<<\/span> \" \"<\/span>;\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n    std::<\/span>remove_if(myVec.begin(), myVec.end(), [](int<\/span> ele){ return<\/span> ele <<\/span> 0<\/span>; }); \/\/ (1)<\/span>\r\n    for<\/span> (auto<\/span> ele:<\/span> myVec) std::<\/span>cout <<<\/span> ele <<<\/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
The program removeElemtens.cpp<\/code> removes all elements the std::vector<\/code> that is smaller than zero. Easy, or? Now, you fall into the well-known trap to each professional  C++ programmer. <\/p>\n
\"eraseRemove\"<\/p>\n
std::remove <\/code>or std::remove_if<\/code>  inline (1) does not remove anything. The std::vector<\/code> still has the same number of arguments. Both algorithms return the new logical end of the modified container. <\/p>\n
To modify a container, you must apply the new logical end to the container.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ eraseRemoveElements.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>vector myVec{-<\/span>2<\/span>, 3<\/span>, -<\/span>5<\/span>, 10<\/span>, 3<\/span>, 0<\/span>, -<\/span>5<\/span> };\r\n\r\n    for<\/span> (auto<\/span> ele:<\/span> myVec) std::<\/span>cout <<<\/span> ele <<<\/span> \" \"<\/span>;\r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n\\n<\/span>\"<\/span>;\r\n\r\n    auto<\/span> newEnd =<\/span> std::<\/span>remove_if(myVec.begin(), myVec.end(),        \/\/ (1)<\/span>
                                 [](int<\/span> ele){ return<\/span> ele <<\/span> 0<\/span>; });\r\n    myVec.erase(newEnd, myVec.end());                               \/\/ (2)<\/span>\r\n    \/\/ myVec.erase(std::remove_if(myVec.begin(), myVec.end(),       \/\/ (3)<\/span>
                   [](int ele){ return ele < 0; }), myVec.end());<\/span>\r\n    for<\/span> (auto<\/span> ele:<\/span> myVec) std::<\/span>cout <<<\/span> ele <<<\/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
Line (1) returns the new logical end newEnd<\/code> of the container myVec<\/code>. This new logical end is applied in line (2) to remove all elements from myVec<\/code> starting at newEnd<\/code>. When you apply the functions remove and erase in one expression, such as in line (3), you exactly see why this construct is called erase-remove-idiom.<\/p>\n
\"eraseRemoveElements\"<\/p>\n
Thanks to the new functions erase<\/code> and erase_if<\/code> in C++20, erasing elements from containers is way more convenient.<\/p>\n<\/p>\n
erase<\/code> and erase_if<\/code> in C++20<\/h2>\n
With erase<\/code> and erase_if<\/code>, you can directly operate on the container. In contrast, the previously presented erase-remove idiom is quite lengthy (line 3 in eraseRemoveElements.cpp<\/code>): erase<\/code> requires two iterators which I provided by the algorithm std::remove_if<\/code>.<\/p>\n
Let’s see what the new functions erase<\/code> and erase_if<\/code> mean in practice. The following program erases elements for a few containers.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ eraseCpp20.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <numeric><\/span>\r\n#include <deque><\/span>\r\n#include <list><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont>                                         \/\/ (7)<\/span><\/span>\r\nvoid<\/span> eraseVal(Cont&<\/span> cont, int<\/span> val) {\r\n    std::<\/span>erase(cont, val);\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont, typename<\/span> Pred>                          \/\/ (8)<\/span><\/span>\r\nvoid<\/span> erasePredicate(Cont&<\/span> cont, Pred pred) {\r\n    std::<\/span>erase_if(cont, pred);\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont><\/span>\r\nvoid<\/span> printContainer(Cont&<\/span> cont) {\r\n    for<\/span> (auto<\/span> c:<\/span> cont) std::<\/span>cout <<<\/span> c <<<\/span> \" \"<\/span>;\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont>                                         \/\/ (6)<\/span><\/span>\r\nvoid<\/span> doAll(Cont&<\/span> cont) {\r\n    printContainer(cont);\r\n    eraseVal(cont, 5<\/span>);\r\n    printContainer(cont);\r\n    erasePredicate(cont, [](auto<\/span> i) { return<\/span> i >=<\/span> 3<\/span>; } );\r\n    printContainer(cont);\r\n}\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>string str{\"A Sentence with an E.\"<\/span>};\r\n    std::<\/span>cout <<<\/span> \"str: \"<\/span> <<<\/span> str <<<\/span> std::<\/span>endl;\r\n    std::<\/span>erase(str, 'e'<\/span>);                                        \/\/ (1)<\/span>\r\n    std::<\/span>cout <<<\/span> \"str: \"<\/span> <<<\/span> str <<<\/span> std::<\/span>endl;\r\n    std::<\/span>erase_if( str, [](char<\/span> c){ return<\/span> std::<\/span>isupper(c); });  \/\/ (2)<\/span>\r\n    std::<\/span>cout <<<\/span> \"str: \"<\/span> <<<\/span> str <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>std::vector \"<\/span> <<<\/span> std::<\/span>endl;\r\n    std::<\/span>vector vec{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>};                  \/\/ (3)<\/span>\r\n    doAll(vec);\r\n    \r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>std::deque \"<\/span> <<<\/span> std::<\/span>endl;\r\n    std::<\/span>deque deq{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>};                   \/\/ (4)<\/span>\r\n    doAll(deq);\r\n    \r\n    std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>std::list\"<\/span> <<<\/span> std::<\/span>endl;\r\n    std::<\/span>list lst{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>};                    \/\/ (5)<\/span>\r\n    doAll(lst);\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Line (1) erases all character e<\/code> from the given string str.<\/code> Line (2) applies the lambda expression to the same string and erases all upper-case letters.<\/p>\n
In the remaining program, elements of the sequence containers std::vecto<\/code>r (line 3), std::deque<\/code> (line 4), and std::list<\/code> (line 5) are erased. On each container, the function template doAll<\/code> (line 6) is applied. doAll<\/code> erases the element 5 and all elements greater than 3. The function template erase<\/code> (line 7) uses the new function erase<\/code> , and the function template erasePredicate<\/code> (line 8) uses the new function erase_if<\/code>.<\/p>\n
Thanks to the Microsoft Compiler, here is the output of the program.<\/p>\n
\"eraseCpp20\"<\/p>\n
The new functions erase<\/code> and erase_if<\/code> can be applied to all containers of the Standard Template Library. This does not hold for the following convenience function contains<\/code>.<\/p>\n
Checking the Existence of an Element in an Associative Container<\/h2>\n
Thanks to the functions contains<\/code>, you can quickly check if an element exists in an associative container.<\/p>\n
Stopp, you may say, we can already do this with find<\/span> or count. <\/span><\/p>\n
No, both functions are not beginners friendly and have their downsides.<\/p>\n
<\/p>\n
\n
\/\/ checkExistens.cpp<\/span>\r\n\r\n#include <set><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>set mySet{3<\/span>, 2<\/span>, 1<\/span>};\r\n    if<\/span> (mySet.find(2<\/span>) !=<\/span> mySet.end()) {    \/\/ (1)<\/span>\r\n        std::<\/span>cout <<<\/span> \"2 inside\"<\/span> <<<\/span> std::<\/span>endl;\r\n    }\r\n\r\n    std::<\/span>multiset myMultiSet{3<\/span>, 2<\/span>, 1<\/span>, 2<\/span>};\r\n    if<\/span> (myMultiSet.count(2<\/span>)) {            \/\/ (2)<\/span>\r\n        std::<\/span>cout <<<\/span> \"2 inside\"<\/span> <<<\/span> std::<\/span>endl;\r\n    } \r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The functions produce the expected result.<\/p>\n
\"checkExistens\"<\/p>\n
Here are the issues with both calls. The find<\/code> call inline (1) is too lengthy. The same argumentation holds for the count<\/code> call in line (2). The count<\/code> call also has a performance issue. When you want to know if an element is in a container, stop when you found it and not count until the end. In the concrete case, myMultiSet.count(2)<\/code> returned 2.<\/p>\n
On the contrary, the contains member function in C++20 is quite convenient.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ containsElement.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <set><\/span>\r\n#include <map><\/span>\r\n#include <unordered_set><\/span>\r\n#include <unordered_map><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> AssozCont><\/span>\r\nbool<\/span> containsElement5(const<\/span> AssozCont&<\/span> assozCont) {  \/\/ (1)<\/span>\r\n    return<\/span> assozCont.contains(5<\/span>);\r\n}\r\n\r\nint<\/span> main() {\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>set<<\/span>int<\/span>><\/span> mySet{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>};\r\n    std::<\/span>cout <<<\/span> \"containsElement5(mySet): \"<\/span> <<<\/span> containsElement5(mySet);\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>unordered_set<<\/span>int<\/span>><\/span> myUnordSet{1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>, 6<\/span>, 7<\/span>, 8<\/span>, 9<\/span>, 10<\/span>};\r\n    std::<\/span>cout <<<\/span> \"containsElement5(myUnordSet): \"<\/span> <<<\/span> containsElement5(myUnordSet);\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>map<<\/span>int<\/span>, std::<\/span>string><\/span> myMap{ {1<\/span>, \"red\"<\/span>}, {2<\/span>, \"blue\"<\/span>}, {3<\/span>, \"green\"<\/span>} };\r\n    std::<\/span>cout <<<\/span> \"containsElement5(myMap): \"<\/span> <<<\/span> containsElement5(myMap);\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>unordered_map<<\/span>int<\/span>, std::<\/span>string><\/span> myUnordMap{ {1<\/span>, \"red\"<\/span>}, {2<\/span>, \"blue\"<\/span>}, {3<\/span>, \"green\"<\/span>} };\r\n    std::<\/span>cout <<<\/span> \"containsElement5(myUnordMap): \"<\/span> <<<\/span> containsElement5(myUnordMap);\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
There is not much to add to this example. The function template containsElement5<\/code> returns true<\/code> if the associative container contains the key 5. In my example, I only used the associative containers std::set<\/code>, std::unordered_set<\/code>, std::map<\/code>, and std::unordered_set<\/code> which can not have a key more than once.<\/p>\n
\"containsElement\"<\/p>\n
What’s next?<\/h2>\n
The convenience functions go on in my next post<\/a>. With C++20, you can calculate the midpoint of two values, check if a std::string<\/code> start or ends with a substring, and create callables with std::bind_front<\/code>.<\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Removing elements from a container or asking if an associative container has a specific key is too complicated. I should say it was because with C++20, the story changes.<\/p>\n","protected":false},"author":21,"featured_media":5945,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[],"class_list":["post-5995","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5995","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=5995"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5995\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5945"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5995"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5995"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5995"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}