Let’s look at each of the 13 philosophy rules. They should provide the rationale for all 350 rules. <\/a><\/p>\n The following 13 rules cannot be checked thoroughly. Here are they.<\/p>\n I will provide examples from the C++ Core Guidelines for each rule if possible.<\/p>\n<\/p>\n A method should express its intent. Have a look here.<\/p>\n <\/p>\n Neither does the second method month<\/span> express that it will not change the instance nor return a Month<\/span> object.<\/p>\n The same reasoning often holds for explicit loops versus algorithms of the Standard Template Library (STL).<\/p>\n <\/p>\n The meta-rule is obvious. You should know and use the algorithms of the STL.<\/p>\n This rule is simple and has a straightforward enforcement statement: “Use an up-to-date C++ compiler (currently C++11 or C++14) with a set of options that do not accept extensions.”<\/p>\n Your code should express its intent. What can we deduce from the three explicit and implicit loops?<\/p>\n <\/p>\n The elements of the container vec<\/span> will not be modified in (1). On the contrary, the elements in expression (2) will be modified. The algorithm for_each<\/span> is executed with the parallel execution policy (par<\/span>). That means the order of iteration does not matter.<\/p>\n You should strive for statically type-safe programs. Of course, that is impossible because there are problem areas in C++. The C++ Core Guidelines name the problem areas and possible solutions.<\/p>\n gsl stands for Guideline support library GSL. GSL is a small library to support the set of guidelines from the C++ Core Guidelines. I will write about the GSL in an upcoming post.<\/p>\n All that can be done at compile time must not be done at run time. Since C++11, we have the function static_assert<\/span> and the type-traits library. static_assert<\/span> will check a predicate such as static_assert(sizeof(int) >= 4)<\/span> at compile time. Thanks to the type-traits library, we can state powerful conditions about a type T<\/span> at compile time: static_assert(std::is_integral<T>::value).<\/span> Of course, if the check fails at compile-time, the compilation will fail with a readable error message. I <\/span>already wrote about static_assert.<\/span><\/a><\/span><\/p>\n This rule talks about hard-to-detect errors that should be avoided. The examples are about dynamically allocated arrays.<\/p>\n <\/p>\n What’s wrong with the example? The call (1) does not pass the number of elements. (2) makes passing the wrong number of elements possible, and (3) passes the ownership and the size separately. By bypassing a reference or a view (part of the gsl) you can overcome these issues.<\/p>\n Here are the enforcements for this rule:<\/p>\n Leaking resources are, in particular, critical for long-running programs. Resources may be memory but also file handles or sockets. The idiomatic way to solve this issue is RAII. The idea of the RAII idiom is quite simple. You bind a resource’s acquisition and release to the lifetime of a local object. Therefore, the resource will automatically be initialized in the constructor and released in the destructor. The acronym RAII stands for R<\/strong>esource A<\/strong>cquisition I<\/strong>s I<\/strong>nitialization. Smart pointers and locks are based on this technique. Here are more details of RAII<\/a>.<\/p>\n The reason for this rule is quite promising: “This is C++”. One example of the rule is a riddle.<\/p>\n What’s wasted here?<\/p>\n <\/p>\n There are a lot of reasons that speak for immutable data:<\/p>\n Messy code is prone to bugs and harder to write. Therefore, you should encapsulate the low-level code in a function or a method and put a good interface around it.<\/p>\n Computers are better than humans at doing boring and repetitive tasks. That means you should use static analysis, concurrency, and testing tools to automate these verifying steps.<\/p>\n That is quite easy to explain. It would be best to go for well-designed, well-documented, and well-supported libraries. Therefore, you will get a well-tested and nearly error-free library and highly optimized algorithms from domain experts. Two outstanding examples are the C++ standard library and the Guidelines Support Library.<\/p>\n<\/span>Philosophy<\/span><\/h2>\n
![\"800px](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/06\/800px-Head_Platon_Glyptothek_Munich_548.jpg\")
<\/p>\n\n
<\/span>Express ideas directly in code<\/span><\/h3>\n
class<\/span> Date<\/span> {\r\n \/\/ ...<\/span>\r\npublic:<\/span>\r\n Month month() const<\/span>; \/\/ do <\/span>\r\n int<\/span> month<\/span>(); \/\/ don't<\/span>\r\n \/\/ ...<\/span>\r\n};\r\n<\/pre>\n<\/div>\nint<\/span> index =<\/span> -<\/span>1<\/span>; \/\/ bad<\/span>\r\nfor<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> v.size(); ++<\/span>i) {\r\n if<\/span> (v[i] ==<\/span> val) {\r\n index =<\/span> i;\r\n break<\/span>;\r\n }\r\n}\r\n\r\nauto<\/span> p =<\/span> find(begin(v), end(v), val); \/\/ better<\/span>\r\n<\/pre>\n<\/div>\n<\/span>Write in ISO Standard C++<\/span><\/h3>\n
<\/span>Express intent<\/span><\/h3>\n
for<\/span> (const<\/span> auto<\/span>&<\/span> v:<\/span> vec) { ... } (1<\/span>)\r\nfor<\/span> (auto<\/span>&<\/span> v:<\/span> vec){ ... } (2<\/span>)\r\nfor_each(par, vec, [](auto<\/span> v){ ... }); (3<\/span>)\r\n<\/pre>\n<\/div>\n<\/span>Ideally, a program should be statically type-safe<\/span><\/h3>\n
\n
<\/span>Prefer compile-time checking to run-time checking<\/span><\/h3>\n
<\/span>What cannot be checked at compile-time should be checkable at run time<\/span><\/h3>\n
extern<\/span> void<\/span> f<\/span>(int<\/span>*<\/span> p);\r\nextern<\/span> void<\/span> f2<\/span>(int<\/span>*<\/span> p, int<\/span> n);\r\nextern<\/span> void<\/span> f3<\/span>(unique_ptr<<\/span>int<\/span>[]><\/span> uniq, int<\/span> n);\r\n\r\nf(new<\/span> int<\/span>[n]); (1<\/span>)\r\nf2(new<\/span> int<\/span>[n], m); (2<\/span>)\r\nf3(make_unique<<\/span>int<\/span>[]><\/span>(n), m); (3<\/span>)\r\n<\/pre>\n<\/div>\n<\/span>Catch run-time errors early<\/span><\/h3>\n
\n
<\/span>Don’t leak any resource<\/span><\/h3>\n
<\/span>Don’t waste time or space<\/span><\/h3>\n
void<\/span> lower<\/span>(string s)\r\n{\r\n for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> strlen(s); ++<\/span>i) s[i] =<\/span> tolower(s[i]);\r\n}\r\n<\/pre>\n<\/div>\n<\/span>Prefer immutable data to mutable data<\/span><\/h3>\n
\n
<\/span>Encapsulate messy constructs rather than spreading through the code<\/span><\/h3>\n
<\/span>Use supporting tools as appropriate<\/span><\/h3>\n
<\/span>Use support libraries as appropriate<\/span><\/h3>\n
<\/span>What’s next?<\/span><\/h2>\n