{"id":5084,"date":"2016-12-16T18:58:05","date_gmt":"2016-12-16T18:58:05","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/automatic-memory-management-with-containers\/"},"modified":"2023-06-26T12:31:56","modified_gmt":"2023-06-26T12:31:56","slug":"automatic-memory-management-with-containers","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/automatic-memory-management-with-containers\/","title":{"rendered":"Automatic Memory Management of the STL Containers"},"content":{"rendered":"

One of the significant advantages of a C++ string to a C string and of a std::vector<\/span> to a C array is that both C++ containers automatically manage their memory. Of course, that holds for all further containers of the Standard Template Library. In this post, I will look closer at the automatic memory management of std::vector<\/span> and std::string.<\/span><\/p>\n

<\/p>\n

 <\/p>\n

From the user’s perspective, a std::string<\/span> in C++11 feels like a std::vector.<\/span> That is the simple reason I can present them in parallel. Therefore, it fits very well that std::string and std::vector are the essential containers in C++.<\/p>\n

std::string and std::vector<\/h2>\n

The C++ runtime automatically adjusts the size of a std::string<\/span> and std::vector<\/span> to its number of elements. And with C++11 in both directions.<\/p>\n

 <\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62\r\n63\r\n64\r\n65\r\n66\r\n67\r\n68\r\n69<\/pre>\n<\/td>\n
\n
\/\/ stringAndVector.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nvoid<\/span> showInfo(const<\/span> T& t,const<\/span> std::string& name){\r\n\r\n  std::cout << name << \" t.size(): \"<\/span> << t.size() << std::endl;\r\n  std::cout << name << \" t.capacity(): \"<\/span> << t.capacity() << std::endl;\r\n\r\n}\r\n\r\nint<\/span> main(){\r\n    \r\n  std::cout << std::endl;\r\n\r\n  std::string str;\r\n  std::vector<int<\/span>> vec;\r\n  \r\n  std::cout << \"Maximal size: \"<\/span> << std::endl;\r\n  std::cout << \"str.max_size(): \"<\/span> << str.max_size() << std::endl;\r\n  std::cout << \"vec.max_size(): \"<\/span> << vec.max_size() << std::endl;\r\n  std::cout << std::endl;\r\n  \r\n  std::cout << \"Empty string and vector: \"<\/span> << std::endl;\r\n  showInfo(str,\"String\"<\/span>);\r\n  showInfo(vec,\"Vector\"<\/span>);\r\n  std::cout << std::endl;\r\n  \r\n  \r\n  std::cout << \"Initialized with five values: \"<\/span> << std::endl;\r\n  str= {\"12345\"<\/span>};\r\n  vec= {1,2,3,4,5};\r\n  showInfo(str,\"String\"<\/span>);\r\n  showInfo(vec,\"Vector\"<\/span>);\r\n  std::cout << std::endl;\r\n  \r\n  std::cout << \"Added four additional values: \"<\/span> << std::endl;\r\n  str += \"6789\"<\/span>;\r\n  vec.insert(vec.end(),{6,7,8,9});\r\n  showInfo(str,\"String\"<\/span>);\r\n  showInfo(vec,\"Vector\"<\/span>);\r\n  std::cout << std::endl;\r\n  \r\n  \r\n  std::cout << \"Resized to 30 values: \"<\/span> << std::endl;\r\n  str.resize(30);\r\n  vec.resize(30);\r\n  showInfo(str,\"String\"<\/span>);\r\n  showInfo(vec,\"Vector\"<\/span>);\r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"Reserved space for at least 1000 values: \"<\/span> << std::endl;\r\n  str.reserve(1000);\r\n  vec.reserve(1000);\r\n  showInfo(str,\"String\"<\/span>);\r\n  showInfo(vec,\"Vector\"<\/span>);\r\n  std::cout << std::endl;\r\n  \r\n  std::cout << \"Shrinked to the current size: \"<\/span> << std::endl;\r\n  str.shrink_to_fit();\r\n  vec.shrink_to_fit();\r\n  showInfo(str,\"String\"<\/span>);\r\n  showInfo(vec,\"Vector\"<\/span>);\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The program is relatively easy to get. That was my first thought. But wait for a second.<\/p>\n
To spare typing, I wrote the small function showInfo<\/span> (lines 7 – 13). This function returns for a container its size (line 10) and capacity (line 11). The size of a container is its number of elements, and the capacity of a container is the number of elements a container can hold without an additional allocation. Therefore, the capacity of the container has at least to be as big as its size. You can adjust the size of a container with its method resize<\/span> (lines 49 and 50); you can adjust the capacity of a container with its method reserve<\/span> (lines 56 and 57).<\/p>\n<\/p>\n
But, back to the program from top to bottom. I create in lines 19 and 20 an empty string and an empty vector. Afterward, the program displays the maximum number of elements a string or vector can have. After each operation on both containers, it returns their size and capacity. That holds for the initialization of the containers (lines 34 and 35), for the addition of four new elements (lines 42 and 43), the resizing of the containers to 30 elements (lines 49 and 50), and the reserving of additional memory for at least 1000 elements (line 56 and 57). With C++11, you can shrink the container’s capacity to its size with the method shrink_to_fit (lines 63 and 64).<\/p>\n
Before I present the program’s output on Linux and Windows, let me make a few observations.<\/p>\n
    \n
  1. Adjusting the size and capacity of the container is done automatically. I haven’t used any memory operations like new<\/span> and delete.<\/span><\/li>\n
  2. std::string<\/span> and std::vector<\/span> support the same interface. The only exception to this rule is line 41. Here I added a C string to a C++ string.<\/li>\n
  3. By using the method cont.resize(n)<\/span>, the container cont<\/span> will get new default-initialized elements if <\/span>n > cont.size()<\/span> is accurate.<\/li>\n
  4. By using the method cont.reserve(n)<\/span>, the container cont<\/span> will be get new memory for at least n elements if <\/span>n > cont.capacity()<\/span> is true.<\/li>\n
  5. The call shrink_to_fit<\/span> is non-binding. That means the C++ runtime has not have to adjust the capacity of a container to its size. But, my usages of the method shrink_to_fit<\/span> with GCC, clang, or cl.exe always freed the unnecessary memory.<\/li>\n<\/ol>\n
    Here is the output of the program.<\/p>\n
     <\/p>\n
    \"stringAndVector\"\"stringAndVectorWin\"<\/p>\n
    My little astonishment<\/h3>\n
    The program shows that the MSVC 15 STL implementation is slightly more greedy than the GCC 4.8 STL implementation. That holds, in particular, true for std::string.<\/span> Therefore, the empty std::string<\/span> has 15 elements. But I was more astonished that the maximum size of a std::string<\/span> is as big as the maximum size of a std::vector<int> <\/span>on Linux. This is astonishing because an int<\/span> is four times as big as a char<\/span> on Linux and Windows.<\/span><\/span> 
    <\/span><\/p>\n
    <\/p>\n
    \n
    #include <iostream><\/span>\r\n\r\nint<\/span> main(){\r\n    \r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"sizeof(char): \"<\/span> << sizeof<\/span>(char<\/span>) << std::endl;\r\n  std::cout << \"sizeof(int): \"<\/span> << sizeof<\/span>(int<\/span>) << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    \"sizeof\"\"sizeofWin\"<\/p>\n
     <\/p>\n
    You have to interpret both values as maximum values. Any ideas on the discrepancy?<\/p>\n
    My astonishment has disappeared<\/h3>\n
    Thanks to the help of Mark Abraham and Cl\u00e9ment Gregoire, the riddle is solved.<\/p>\n
    Microsoft implementation is more greedy<\/h4>\n
    Microsoft Visuals std::string<\/span> implementation uses internally small string optimization. Therefore, a small string needs no heap allocation and goes directly to the stack. The boundary is exactly 15 characters. GCC will get a conformant string implementation with 5.1. But I used GCC 4.8 in my test.<\/p>\n
    GCC with conformant std::string implementation<\/h4>\n
     If I use GCC 5.3 with a conformant std::string i<\/span>mplementation, the picture will differ.<\/p>\n
     <\/p>\n
    \"stringAndVectorGCC5<\/p>\n
    To use the conformant std::string<\/span> implementation in GCC 5.3,  I must use the compiler flag -D_GLIBCXX_USE_CXX11_ABI=1.<\/span> Now, the maximum size of std::string<\/span> <\/span>is two times that of std::vector<int>.<\/span><\/span> The C++11 standard says about max_size(): “The size of the largest possible string.<\/em>” <\/span><\/span>Now, I’m fine. <\/span><\/span><\/p>\n
    What’s next?<\/h2>\n
    I will have in the next post<\/a> <\/span>a closer look at std::array. std::array<\/span> combines the best of two worlds. On the one hand, std::array<\/span> is as lightweight as a C array; on the other hand, std::array<\/span> supports the same interface as a std::vector.<\/span><\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
    One of the significant advantages of a C++ string to a C string and of a std::vector to a C array is that both C++ containers automatically manage their memory. Of course, that holds for all further containers of the Standard Template Library. In this post, I will look closer at the automatic memory management […]<\/p>\n","protected":false},"author":21,"featured_media":5079,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[498],"class_list":["post-5084","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-memory"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5084","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=5084"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5084\/revisions"}],"predecessor-version":[{"id":6912,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5084\/revisions\/6912"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5079"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5084"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5084"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5084"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}