{"id":5410,"date":"2018-03-23T20:55:18","date_gmt":"2018-03-23T20:55:18","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-rules-to-performance\/"},"modified":"2023-06-26T11:54:15","modified_gmt":"2023-06-26T11:54:15","slug":"c-core-guidelines-rules-to-performance","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-core-guidelines-rules-to-performance\/","title":{"rendered":"C++ Core Guidelines: Rules about Performance"},"content":{"rendered":"

Before I write about the rules of performance, I will do a straightforward job. Accessing the elements of a container one by one.<\/p>\n

<\/p>\n

 <\/p>\n

\"cheetah\"<\/p>\n

Here is the last rule for arithmetic.<\/p>\n

ES.107: Don\u2019t use unsigned<\/code> for subscripts, prefer gsl::index<\/code><\/a><\/h3>\n

Did I say that this is a simple job? Honestly, this was a lie.  See what can go wrong. Here is an example of a std::vector.<\/span><\/p>\n

\n
vector<<\/span>int<\/span>><\/span> vec =<\/span> \/*...*\/<\/span>;\r\n\r\nfor<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> vec.size(); i +=<\/span> 2<\/span>)                    \/\/ may not be big enough (2)<\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\nfor<\/span> (unsigned<\/span> i =<\/span> 0<\/span>; i <<\/span> vec.size(); i +=<\/span> 2<\/span>)               \/\/ risk wraparound       (3)<\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\nfor<\/span> (auto<\/span> i =<\/span> 0<\/span>; i <<\/span> vec.size(); i +=<\/span> 2<\/span>)                   \/\/ may not be big enough (2)<\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\nfor<\/span> (vector<<\/span>int<\/span>>::<\/span>size_type i =<\/span> 0<\/span>; i <<\/span> vec.size(); i +=<\/span> 2<\/span>) \/\/ verbose               (1)<\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\nfor<\/span> (auto<\/span> i =<\/span> vec.size()-<\/span>1<\/span>; i >=<\/span> 0<\/span>; i -=<\/span> 2<\/span>)                \/\/ bug                   (4) <\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\nfor<\/span> (int<\/span> i =<\/span> vec.size()-<\/span>1<\/span>; i >=<\/span> 0<\/span>; i -=<\/span> 2<\/span>)                 \/\/ may not be big enough (2)<\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Scary? Right! Only line (1) is correct. It may happen in line (2) that the variable i i<\/span>s too small. The result may be an overflow. This will not hold for line (3) because i<\/span> is unsigned<\/span>. Instead of an overflow, you will get a modulo operation. In my last post, I wrote about this nice effect: C++ Core Guidelines: Rules to Statements and Arithmetic<\/a>. To be more specific, it was ruled ES.106.<\/p>\n
Line 4 is left. This is my favorite one. What is the problem? The problem is that vec.size()<\/span> is of type std::size_t. std::size_t<\/span> is an unsigned type <\/span>and can not represent negative numbers. Imagine what would happen if the vector was empty. This means that vec.size() -1<\/span> is –1. <\/span>The result is that we get the maximum value of type std::size_t.<\/span><\/p>\n
The program index.cpp<\/span> shows this strange behavior.<\/p>\n
 <\/p>\n
\n
\/\/ index.cpp<\/span>\r\n\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<<\/span>int<\/span>><\/span> vec{};\r\n    \r\n    auto<\/span> ind1 =<\/span> vec.size() -<\/span> 1<\/span> ;\r\n    int<\/span> ind2 =<\/span> vec.size() -<\/span>1<\/span> ;\r\n    \r\n    std::<\/span>cout <<<\/span> \"ind1: \"<\/span> <<<\/span> ind1 <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"ind2: \"<\/span> <<<\/span> ind2 <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
 And here is the output:<\/p>\n
\"index\"<\/p>\n
The guidelines suggest that the variable i should be of type gsl::index.<\/span><\/p>\n
 <\/p>\n
\n
for<\/span> (gsl::<\/span>index i =<\/span> 0<\/span>; i <<\/span> vec.size(); i +=<\/span> 2<\/span>)             \/\/ ok<\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\nfor<\/span> (gsl::<\/span>index i =<\/span> vec.size()-<\/span>1<\/span>; i >=<\/span> 0<\/span>; i -=<\/span> 2<\/span>)          \/\/ ok<\/span>\r\n    cout <<<\/span> vec[i] <<<\/span> '\\n'<\/span>;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
If this is not an option, use the type std::vector<int>::size_type<\/span> for i.<\/p>\n
Performance is the domain of C++! Right? Therefore I was pretty curious to write about the rules for performance. But this is hardly possible because most of the rules lack beef. They consist of a title and a reason. Sometimes even the reason is missing.<\/p>\n
Anyway. Here are the first rules:<\/p>\n