{"id":5699,"date":"2019-06-05T20:19:36","date_gmt":"2019-06-05T20:19:36","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-avoid-bound-errors\/"},"modified":"2023-06-26T10:07:12","modified_gmt":"2023-06-26T10:07:12","slug":"c-core-guidelines-avoid-bound-errors","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-avoid-bound-errors\/","title":{"rendered":"C++ Core Guidelines: Avoid Bounds Errors"},"content":{"rendered":"

When you access an element outside a container of the STL, the result is not so promising. Your effect may be an error or undefined behavior. Undefined behavior means all bets are open.<\/p>\n

<\/p>\n

 <\/p>\n

\"brno<\/p>\n

 <\/div>\n

First of all: What is a bounds error? A bounds error happens when you read or write beyond the elements of a container. The result is different depending on the used container. Of course, the C++ core guidelines are very concrete.<\/p>\n

SL.con.3: Avoid bounds errors<\/a><\/h3>\n

The C++ core guidelines start with a bad example using unsafe C-functions to fill and compare a std::array<\/span>.<\/p>\n

\n
std::array<<\/span>int<\/span>, 10<\/span>><\/span> a, b;\r\nstd::memset(a.data(), 0<\/span>, 10<\/span>);         \/\/ BAD, and contains a length error (length = 10 * sizeof(int))<\/span>\r\nstd::memcmp(a.data(), b.data(), 10<\/span>);  \/\/ BAD, and contains a length error (length = 10 * sizeof(int))<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The comments to the code already say it. The length of the C-arrays is not 10 but 10 * sizeof(int). The solution is obvious. Use the functionality of the std::array<\/span>.<\/p>\n
 <\/p>\n
\n
std::<\/span>array<<\/span>int<\/span>, 10<\/span>><\/span> a;\r\nstd::<\/span>array<<\/span>int<\/span>, 10<\/span>><\/span> b;\r\n\r\nstd::<\/span>array<<\/span>int<\/span>, 10<\/span>><\/span> c{};           \r\n\r\na.fill(0<\/span>);                         \/\/ (1)<\/span>\r\nstd::<\/span>fill(b.begin(), b.end(), 0<\/span>);  \/\/ (2)  <\/span>\r\n\r\nif<\/span> ( a ==<\/span> b ){                     \/\/ (3)<\/span>\r\n    \/\/ ...<\/span>\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
In this case, the std::array a<\/span> and b<\/span> are not initialized. On the opposite, all values of care are initialized to 0. Line (1) sets all values of a to 0, and line 2 uses the function templates std:<\/span>:fill.<\/span> Comparison is also quite convenient (line 3).<\/p>\n
Using a container outsides its range is, in general, undefined behavior. Let me see what that means.<\/p>\n<\/p>\n
Bounds Errors<\/h3>\n
The most elementary sequential container we have in C++ is the C-array.<\/p>\n
C-Array<\/h3>\n
The effect of an overflow or an underflow is the same: memory corruption and undefined behavior. Let’s make a simple test with an int<\/span> array. How long will the next program run?<\/p>\n
\n
\/\/ overUnderflow.cpp<\/span>\r\n\r\n#include <cstddef><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    int<\/span> a[0<\/span>];\r\n    int<\/span> n{};\r\n\r\n    while<\/span> (true<\/span>){\r\n        if<\/span> (!<\/span>(n %<\/span> 100<\/span>)){\r\n            std::<\/span>cout <<<\/span> \"a[\"<\/span> <<<\/span> n <<<\/span> \"] = \"<\/span> <<<\/span> a[n] <<<\/span> \", a[\"<\/span> <<<\/span> -<\/span>n <<<\/span> \"] = \"<\/span> <<<\/span> a[-<\/span>n] <<<\/span> \"<\/span>\\n<\/span>\"<\/span>;\r\n        }\r\n        a[n] =<\/span> n;\r\n        a[-<\/span>n] =<\/span> -<\/span>n;\r\n        ++<\/span>n;\r\n    }\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Way too long! The program writes each 100th array entry to std::cout.<\/span> <\/p>\n
\"overUnderflow\"<\/p>\n
Okay, what will happen if I use a sequential container from the STL? Here we are:<\/p>\n
Sequential Containers of the STL<\/h3>\n
The index operator is available for std::array, std::vector, std::deque<\/span>, and std::string<\/span>. For simplicity reasons, I count a std::string<\/span> as a sequential container. This means all containers support random access and return a random access iterator. To bore you not to death, I use only a std::array and a std::vector in my next experiment. <\/p>\n
std::array<\/span><\/h4>\n
This is the modified program for std::array<\/span>:<\/p>\n
\n
\/\/ overUnderflowStdArray.cpp<\/span>\r\n\r\n#include <array><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>array<<\/span>int<\/span>, 1<\/span>><\/span> a;\r\n    int<\/span> n{};\r\n\r\n    while<\/span> (true<\/span>){\r\n        if<\/span> (!<\/span>(n %<\/span> 100<\/span>)){\r\n            std::<\/span>cout <<<\/span> \"a[\"<\/span> <<<\/span> n <<<\/span> \"] = \"<\/span> <<<\/span> a[n] <<<\/span> \r\n                       \", a[\"<\/span> <<<\/span> -<\/span>n <<<\/span> \"] = \"<\/span> <<<\/span> a[-<\/span>n] <<<\/span> \"<\/span>\\n<\/span>\"<\/span>;\r\n        }\r\n        a[n] =<\/span> n;\r\n        a[-<\/span>n] =<\/span> -<\/span>n;\r\n        ++<\/span>n;\r\n    }\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Using the index operator for a C++ array is not better than using it for a C array.<\/p>\n
\"overUnderflowStdArray\"<\/p>\n
Maybe, a std::vector<\/span> comes to our rescue.<\/p>\n
std::vector<\/span><\/h4>\n
 <\/p>\n
\n
\/\/ overUnderflowStdVector.cpp<\/span>\r\n\r\n#include <vector><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>vector<<\/span>int<\/span>><\/span> a{1<\/span>};\r\n    int<\/span> n{};\r\n\r\n    while<\/span> (true<\/span>){\r\n        if<\/span> (!<\/span>(n %<\/span> 100<\/span>)){\r\n            std::<\/span>cout <<<\/span> \"a[\"<\/span> <<<\/span> n <<<\/span> \"] = \"<\/span> <<<\/span> a[n] <<<\/span> \r\n                       \", a[\"<\/span> <<<\/span> -<\/span>n <<<\/span> \"] = \"<\/span> <<<\/span> a[-<\/span>n] <<<\/span> \"<\/span>\\n<\/span>\"<\/span>;\r\n        }\r\n        a[n] =<\/span> n;\r\n        a[-<\/span>n] =<\/span> -<\/span>n;\r\n        ++<\/span>n;\r\n    }\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Because the std::vector<\/span> creates its objects on the heap and not on the stack, such as the C- and C++-array, it takes quite a while for the program to fail. The screenshots show the beginning and the end of the under- and overflow.<\/p>\n
\"overUnderflowStdVector1\"<\/p>\n
 <\/p>\n
\"overUnderflowStdVector2\"<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
Additionally, associative containers such as std::map<\/span> and std::unordered_map<\/span> also support the index operator.<\/p>\n
Associative Containers of the STL<\/h3>\n
What happens when you use a non-existing key in a <\/span>std::map <\/span>or<\/span> std::unordered_map<\/span>?<\/p>\n
 <\/p>\n
\n
\/\/ indexOperatorMapAndUnorderedMap.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <map><\/span>\r\n#include <unordered_map><\/span>\r\n#include <string><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> std::<\/span>endl;\r\n\r\n    std::<\/span>map<<\/span>std::<\/span>string, int<\/span>><\/span> myMap;\r\n    std::<\/span>unordered_map<<\/span>std::<\/span>string, bool<\/span>><\/span> myUnorderedMap;\r\n\t\r\n    std::<\/span>cout <<<\/span> \"myMap[DoesNotExist]: \"<\/span> <<<\/span> myMap[\"DoesNotExist\"<\/span>] <<<\/span> std::<\/span>endl;\r\n\t\r\n    std::<\/span>cout <<<\/span> \"myUnorderedMap[DoesNotExist]: \"<\/span> <<<\/span> myUnorderedMap[\"DoesNotExist\"<\/span>] <<<\/span> std::<\/span>endl;\r\n\t\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
In the case of the associative container, the value you get is well-defined if the key is unavailable. The value must be DefaultConstructible because the default constructor is invoked if the key is unavailable. This creates der literal 0 in the first case and the literal false<\/span> in the second case.<\/p>\n
\"indexOperatorMapAndUnorderedMap\"<\/p>\n
Okay, the essential question of the guideline remains: How can you avoid bounds errors?<\/p>\n
Avoid bounds errors<\/h3>\n
In the case of the C-array, there is no rescue to detect a bounds error. For the C++ containers, including std::string<\/span>, there is a method at<\/span> which checks the bounds. All C++ container throws a std::out_of_range<\/span> exception if you access a non-existing element. The std::string<\/span> shows this impressive.<\/p>\n
 <\/p>\n
\n
\/\/ stringBoundsCheck.cpp<\/span>\r\n\r\n#include <stdexcept><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/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>string str(\"1123456789\"<\/span>); \r\n \r\n    str.at(0<\/span>) =<\/span> '0'<\/span>;                                   \/\/ (1)<\/span>\r\n    \r\n    std::<\/span>cout <<<\/span> str <<<\/span> std::<\/span>endl;\r\n \r\n    std::<\/span>cout <<<\/span> \"str.size(): \"<\/span> <<<\/span> str.size() <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"str.capacity() = \"<\/span> <<<\/span> str.capacity() <<<\/span> '\\n'<\/span>;\r\n \r\n    try {\r\n        str.at(12<\/span>) =<\/span> 'X'<\/span>;                              \/\/ (2)<\/span>\r\n    }\r\n    catch<\/span> (const<\/span> std::<\/span>out_of_range&<\/span> exc) {\r\n        std::<\/span>cout <<<\/span> exc.what() <<<\/span> std::<\/span>endl;\r\n    }\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n    \r\n<\/pre>\n<\/div>\n
 <\/p>\n
Setting the first character of the string str<\/span> to ‘0’ (line 1) is fine, but accessing a character outside the size is an error. This even holds if the access is within the capacity but outside the size of the std::string<\/span>.<\/p>\n
    \n
  1. The size of a std::string<\/span> is the number of elements the std::string<\/span> has.<\/li>\n
  2. The capacity of a std::string is the number of elements a std::string<\/span> could have without allocating additional memory. <\/li>\n<\/ol>\n
    The error message of the windows compiler 19.20 is unspecific.<\/p>\n
    \"stringBoundsCheckWin\"<\/p>\n
    The error message for GCC 8.2 is quite specific.<\/p>\n
    \"stringBoundsCheck\"<\/p>\n
    What’s next?<\/h2>\n
    This post was the last one to the containers of the STL. The next post<\/a> is about the various string types.<\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    When you access an element outside a container of the STL, the result is not so promising. Your effect may be an error or undefined behavior. Undefined behavior means all bets are open.<\/p>\n","protected":false},"author":21,"featured_media":5692,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[372],"tags":[472,470],"class_list":["post-5699","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-modern-c","tag-associative-containers","tag-performance"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5699","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=5699"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5699\/revisions"}],"predecessor-version":[{"id":6785,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5699\/revisions\/6785"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5692"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5699"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5699"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5699"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}