From 59eb77027ee8ac3b71eda551f30278beed59d7ae Mon Sep 17 00:00:00 2001 From: Sergey Zubkov Date: Tue, 2 Jan 2018 22:15:02 -0500 Subject: [PATCH] travis CI fixes --- CppCoreGuidelines.md | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/CppCoreGuidelines.md b/CppCoreGuidelines.md index 4f71d8c..c6fbcad 100644 --- a/CppCoreGuidelines.md +++ b/CppCoreGuidelines.md @@ -1,6 +1,6 @@ # C++ Core Guidelines -Janualy 1, 2018 +January 1, 2018 Editors: @@ -6867,7 +6867,7 @@ The implementation hierarchy can be used directly, rather than through the abstr } This can be useful when the implementation class has members that are not offered in the abstract interface -or if direct use of a member offers optimization oppertunities (e.g., if an implementation member function is `final`) +or if direct use of a member offers optimization opportunities (e.g., if an implementation member function is `final`) ##### Note @@ -10076,7 +10076,7 @@ Assuming that there is a logical connection between `i` and `j`, that connection } auto [i, j] = make_related_widgets(cond); // C++17 - + ##### Note Complex initialization has been popular with clever programmers for decades. @@ -12433,15 +12433,15 @@ This invokes `istream`'s `operator bool()`. ##### Note Explicit comparison of an integer to `0` is in general not redundant. -The reason is that (as opposed to pointers and Booleans) an integer often have more than two resonable values. +The reason is that (as opposed to pointers and Booleans) an integer often has more than two reasonable values. Furthermore `0` (zero) is often used to indicate success. Consequently, it is best to be specific about the comparison. void f(int i) { - if (i) // suspect + if (i) // suspect // ... - if (i==success) // possibly better + if (i == success) // possibly better // ... } @@ -13115,20 +13115,20 @@ Type violations, weak types (e.g. `void*`s), and low-level code (e.g., manipulat To decrease code size and run time. To avoid data races by using constants. -To catch errors at compiler time (and thus eliminate the need for error-handling code). +To catch errors at compile time (and thus eliminate the need for error-handling code). ##### Example double square(double d) { return d*d; } static double s2 = square(2); // old-style: dynamic initialization - constexpr double ntimes(double d, int n) // assume 0<=n> + constexpr double ntimes(double d, int n) // assume 0 <= n { double m = 1; - while (n--) m*=d; + while (n--) m *= d; return m; } - constexpr double s3 {ntimes(2,3)}; // modern-style: compile-time initialization + constexpr double s3 {ntimes(2, 3)}; // modern-style: compile-time initialization Code like the initialization of `s2` isn't uncommon, especially for initialization that's a bit more complicated than `square()`. However, compared to the initialization of `s3` there are two problems: @@ -13148,25 +13148,25 @@ Consider a popular technique for providing a handle for storing small objects in struct Scoped { // store a T in Scoped // ... T obj; - }; + }; template - struct On_heap { // store a T in on the free store + struct On_heap { // store a T on the free store // ... T* objp; - }; + }; template - using Handle = typename std::conditional<(sizeof(T)<=on_stack_max), - Scoped, // first alternative - On_heap // second alternative - >::type; + using Handle = typename std::conditional<(sizeof(T) <= on_stack_max), + Scoped, // first alternative + On_heap // second alternative + >::type; void f() { - Handle v1; // the double goes on the stack - Handle> v2; // the array goes on the free store - // ... + Handle v1; // the double goes on the stack + Handle> v2; // the array goes on the free store + // ... } Assume that `Scoped` and `On_heap` provide compatible user interfaces. @@ -13476,7 +13476,7 @@ Making `surface_readings` be `const` (with respect to this function) allow reaso Immutable data can be safely and efficiently shared. No locking is needed: You can't have a data race on a constant. -See also [CP.mess: Message Passing](#SScp-messs) and [CP.31: prefer pass by value](#C#Rconc-data-by-value). +See also [CP.mess: Message Passing](#SScp-mess) and [CP.31: prefer pass by value](#C#Rconc-data-by-value). ##### Enforcement @@ -18651,7 +18651,7 @@ Use `gsl::span` for non-owning references into a container. Comparing the performance of a fixed-sized array allocated on the stack against a `vector` with its elements on the free store is bogus. You could just as well compare a `std::array` on the stack against the result of a `malloc()` accessed through a pointer. -For most code, even the difference between stack allocation and free-store allocation doesn't matter, but the convenieance and safety of `vector` does. +For most code, even the difference between stack allocation and free-store allocation doesn't matter, but the convenience and safety of `vector` does. People working with code for which that difference matters are quite capable of choosing between `array` and `vector`. ##### Enforcement