{"id":5255,"date":"2017-05-07T20:20:57","date_gmt":"2017-05-07T20:20:57","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-17-the-improved-interface-of-the-associative-containers\/"},"modified":"2023-06-26T12:17:04","modified_gmt":"2023-06-26T12:17:04","slug":"c-17-the-improved-interface-of-the-associative-containers","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-17-the-improved-interface-of-the-associative-containers\/","title":{"rendered":"C++17: Improved Associative Containers and Uniform Container Access"},"content":{"rendered":"

C++11 has eight associative containers. With C++17, you can more comfortably insert new elements into them, merge existing associative containers, or move elements from one container into another if they are similar. But that is not all. The access to the associative and sequential containers was unified.<\/p>\n

<\/p>\n

Before I dive into the details, let me first answer the question: What do I mean by similar associative containers? We have eight associative containers. Here are they.<\/p>\n

\"\"<\/p>\n

By similar, I mean their elements have the same structure and data types. The elements of std::set<\/span> and std::multiset<\/span>, std::unordered_set<\/span> and std::unordered_multiset<\/span>, std::map<\/span> and std::multimap<\/span>, and std::unordered_map<\/span> and std::unordered_multimap<\/span> have the same structure. <\/p>\n

Of course, that was only a high-level overview of the eight associative containers. That is for two reasons. First, I want to write about the improved interface. Second, you can read the details in my previous post: Hash Tables<\/a>. <\/p>\n

Now to something completely new.<\/p>\n

The improved interface of the associative containers<\/h2>\n

Let me show you the improved interface with an exhaustive example.<\/p>\n

\n
\/\/ accociativeContainers.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <map><\/span>\r\n#include <string><\/span>\r\n#include <utility><\/span>\r\n \r\nusing<\/span> namespace<\/span> std::<\/span>literals;                                     \/\/ 1<\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Cont><\/span>\r\nvoid<\/span> printContainer(const<\/span> Cont&<\/span> cont, const<\/span> std::<\/span>string&<\/span> mess){    \/\/ 2<\/span>\r\n  std::<\/span>cout <<<\/span> mess;\r\n  for<\/span> (const<\/span> auto<\/span>&<\/span> pa:<\/span> cont){\r\n    std::<\/span>cout <<<\/span> \"(\"<\/span> <<<\/span> pa.first <<<\/span> \": \"<\/span> <<<\/span> pa.second <<<\/span> \") \"<\/span>;\r\n  }\r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n}\r\n\r\nint<\/span> main(){\r\n  \r\n  std::<\/span>map<<\/span>int<\/span>, std::<\/span>string><\/span> ordMap{{1<\/span>, \"a\"<\/span>s}, {2<\/span>, \"b\"<\/span>}};          \/\/ 3<\/span>\r\n  ordMap.try_emplace(3<\/span>, 3<\/span>, 'C'<\/span>);\r\n  ordMap.try_emplace(3<\/span>, 3<\/span>, 'c'<\/span>);\r\n \r\n  printContainer(ordMap, \"try_emplace: \"<\/span>);\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> ordMap2{{3<\/span>, std::<\/span>string(3<\/span>, 'C'<\/span>)},     \/\/ 4<\/span>\r\n                                      {4<\/span>, std::<\/span>string(3<\/span>, 'D'<\/span>)}};\r\n  ordMap2.insert_or_assign(5<\/span>, std::<\/span>string(3<\/span>, 'e'<\/span>));\r\n  ordMap2.insert_or_assign(5<\/span>, std::<\/span>string(3<\/span>, 'E'<\/span>));\r\n  \r\n  printContainer(ordMap2, \"insert_or_assign: \"<\/span>);                   \/\/ 5<\/span>\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n  \r\n  ordMap.merge(ordMap2);                                           \/\/ 6<\/span>\r\n  \r\n  std::<\/span>cout<<<\/span> \"ordMap.merge(ordMap2)\"<\/span> <<<\/span> std::<\/span>endl;\r\n  \r\n  printContainer(ordMap, \"  ordMap: \"<\/span>);\r\n  printContainer(ordMap2, \"  ordMap2: \"<\/span>);\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>endl;  \r\n  \r\n  std::<\/span>cout <<<\/span> \"extract and insert: \"<\/span> <<<\/span> std::<\/span>endl;\r\n                                                                           \r\n  std::<\/span>multimap<<\/span>int<\/span>, std::<\/span>string><\/span> multiMap{{2017<\/span>, std::<\/span>string(3<\/span>, 'F'<\/span>)}};  \r\n  \r\n  auto<\/span> nodeHandle =<\/span> multiMap.extract(2017<\/span>);                        \/\/ 7<\/span>\r\n  nodeHandle.key() =<\/span> 6<\/span>;                                           \r\n  ordMap.insert(std::<\/span>move(nodeHandle));                         \r\n\r\n  printContainer(ordMap, \"   ordMap: \"<\/span>);\r\n  printContainer(multiMap, \"   multiMap: \"<\/span>);\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I use in the example a std::map<\/span> because, most of the time, a std::map<\/span> is your first choice for an associative container. If your associative container is big and performance is critical, think about a std::unordered_map<\/span>. In the post Associative Containers – A simple Performance Comparison<\/a> are a few performance numbers.<\/p>\n
To simplify my life, I wrote the function template printContainer (2) to display the associative container with a short message. The same argument holds for using namespace std::literals <\/span>expression (1). Now, I can use the new built-in literal for a C++ string. You see its usage in the key\/value pair {1, “a”s}<\/span> in (3). “a”s<\/span> is the C++ string literal that has been available since C++14. You must add the character s<\/span> to the C string literal “a”<\/span> to get a C++ string literal.<\/p>\n
Now, I will explain the program in detail. To get a better idea of it, peek at the output.<\/p>\n
\"accociativeContainers\"<\/p>\n
There are two new ways to add elements to an associative container: try_emplace<\/span> and insert_or_assign<\/span>. ordMap.try_emplace(3, 3, ‘C’)<\/span> (3) tries to add a new element to ordMap<\/span>. The first 3<\/span> is the key of the element, and the following 3<\/code> and ‘C’<\/span> directly go to the constructor of the value, which is, in this case, a std::string<\/span>. It’s called try. Therefore, if the key is already in the std::map<\/span>, nothing happens. ordMap2.insert_or_assign(5, std::string(3, ‘e’))<\/span> (4) behaves different. The first call (4) inserts the key\/value pair 5<\/span>, std::string(“eee”)<\/span>, and the second call assigns the std::string(“EEE”)<\/span> to the key 5<\/span>.<\/p>\n
With C++17, you can merge associative Containers (6). ordMap.merge(ordMap2)<\/span> will merge the associative container ordMap2 <\/span>into ordMap<\/span>. Formally this process is called “splice”. That means each node consisting of the key\/value pair will be extracted from ordMap2<\/span> and inserted into ordMap<\/span> if the key is unavailable in ordMap<\/span>. If the key is already in ordMap<\/span>, nothing will happen. There is no copy or move operation involved. All pointers and references to the transferred node remain valid.  You can merge nodes between similar containers. Associative containers must have the same structure and the same data types.<\/p>\n
The extracting and inserting goes on (7). As mentioned, each associative container has a new subtype: node_type<\/span>. I implicitly used it by merging one container into another (6). You can even use the no<\/span>de_type to change a key of a key\/value pair. Have a look here. auto nodeHandle multiMap.extract(2017)<\/span> extracts the node with the key 2017 from the std::multimap<int, std::string><\/span>. In the following lines, I change the key to 6: nodeHandle.key() = 6<\/span> and insert it into ordMap<\/span>. I have to move the node, and copying is not possible.<\/p>\n
Of course, I also can insert the node into the same associative container (A) from which I extracted it or insert the node into the ordMap<\/span> without changing the key (B). You can also change the value of node (C).<\/p>\n
 <\/p>\n
<\/p>\n
\n
auto<\/span> nodeHandle =<\/span> multiMap.extract(2017<\/span>);   \/\/ A                      <\/span>\r\nnodeHandle.key() =<\/span> 6<\/span>;\r\nmultiMap.insert(std::<\/span>move(nodeHandle));\r\n  \r\n\r\nauto<\/span> nodeHandle =<\/span> multiMap.extract(2017<\/span>);   \/\/ B                     <\/span>\r\nordMap.insert(std::<\/span>move(nodeHandle)); \r\n\r\n\r\nauto<\/span> nodeHandle =<\/span> multiMap.extract(2017<\/span>);   \/\/ C<\/span>\r\nnodeHandle.key() =<\/span> 6<\/span>;\r\nordMap.insert(std::<\/span>move(nodeHandle));   \r\nordMap[6<\/span>] =<\/span> std::<\/span>string(\"ZZZ\"<\/span>);\r\n<\/pre>\n<\/div>\n
 <\/p>\n
If you extract a node from an associative container (A) having a value such as std::map<\/span>, std::unordered_map<\/span>, std::multimap<\/span>, or std::unordered_multimap<\/span>, you get a node nodeHandleMap<\/span>, on which you can invoke nodeHandleMap.key()<\/span>. There is no method nodeHandleMap.value() <\/span>to change the node’s value. Curiously enough, if you extract a node nodeHandleSet<\/span> from a std::set<\/span> or one of its three siblings, you can change the key by invoking nodeHandleSet.value()<\/span>.<\/p>\n
 C++17 get three new global functions for accessing a container.<\/p>\n<\/p>\n
Uniform container access<\/h2>\n
The three new functions are named std::size, std::empty,<\/span> and std::data<\/span>.<\/p>\n