{"id":6030,"date":"2020-11-17T21:21:20","date_gmt":"2020-11-17T21:21:20","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/safe-comparisons-of-integrals-with-c-20\/"},"modified":"2020-11-17T21:21:20","modified_gmt":"2020-11-17T21:21:20","slug":"safe-comparisons-of-integrals-with-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/safe-comparisons-of-integrals-with-c-20\/","title":{"rendered":"Safe Comparisons of Integrals with C++20"},"content":{"rendered":"

 When you compare signed and unsigned integers, you may not get the result you expect. Thanks to the six std::cmp_<\/code>* functions, there is a cure in C++20.<\/p>\n

<\/p>\n

 \"TimelineCpp20CoreLanguage\"<\/p>\n

Maybe, you remember the rule “ES.100 Don’t mix signed and unsigned arithmetic” <\/a>from the C++ Core Guidelines. I wrote a few words about it in my previous post on “Arithmetic Rules<\/a>“. Today, I want to investigate this issue and compare signed and unsigned integers.<\/p>\n

Let’s start with an unsafe comparison.<\/p>\n

Unsafe Comparison of Integrals<\/h2>\n

 Of course, there is a reason for the program name unsafeComparison.cpp<\/code>.<\/p>\n

 <\/p>\n

<\/p>\n

\n
\/\/ unsafeComparison.cpp<\/span>\r\n\r\n#include <iostream><\/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>cout <<<\/span> std::<\/span>boolalpha;\r\n\r\n    int<\/span> x =<\/span> -<\/span>3<\/span>;                  \/\/ (1)<\/span>\r\n    unsigned<\/span> int<\/span> y =<\/span> 7<\/span>;          \/\/ (2)<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> \"-3 < 7:  \"<\/span> <<<\/span> (x <<\/span> y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"-3 <= 7: \"<\/span> <<<\/span> (x <=<\/span> y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"-3 > 7:  \"<\/span> <<<\/span> (x ><\/span> y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"-3 => 7: \"<\/span> <<<\/span> (x >=<\/span> y) <<<\/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
When I execute the program, the output may not meet your expectations.<\/p>\n
\"unsafeComparison\"<\/p>\n
When you read the program output, you recognize -3 should be bigger than 7. You presumably know the reason. I compared a signed x<\/code> (line (1)) with an unsigned y<\/code> (line (2)). What is happening under the hood? The following program provides the answer.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ unsafeComparison2.cpp<\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n    int<\/span> x =<\/span> -<\/span>3<\/span>;\r\n    unsigned<\/span> int<\/span> y =<\/span> 7<\/span>;\r\n\r\n    bool<\/span> val =<\/span> x <<\/span> y;              \/\/ (1)<\/span>\r\n    static_assert(static_cast<\/span><<\/span>unsigned<\/span> int<\/span>><\/span>(-<\/span>3<\/span>) ==<\/span> 4'294'967'293<\/span>);\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
In the example, I’m focusing on the less-than-operator. C++ Insights<\/a> gives me the following output:<\/p>\n
\"unsafeComparison2\"<\/p>\n
Here is what’s happening:<\/p>\n
    \n
  1. The compiler transforms the expression x < y <\/code>(line 1) into static_cast<unsigned int>(x) < y<\/code>. In particular, the signed<\/code> x<\/code> is converted to an unsigned int.<\/li>\n
  2. Due to the conversion, -3 <\/code>becomes 4’294’967’293. <\/li>\n
  3.  4'294'967'293<\/code> is equal to (-3) modulo (2 to the power of 32).<\/li>\n
  4. 32 is the number of bits of an unsigned int<\/code> on C++ Insights.\n<\/li>\n<\/ol>\n
    Thanks to C++20, we have a safe comparison of integrals.<\/p>\n<\/p>\n
    Safe Comparison of Integrals<\/h2>\n
    C++20 supports the six comparison functions for integrals:<\/p>\n
     <\/p>\n
    \"compareFunctionsEng1\"<\/p>\n
    Thanks to the six comparison functions, I can easily transform the previous program unsafeComparison.cpp<\/code> into the program safeComparison.cpp. <\/code>The new comparison functions require the header <utility<\/code>>.
    <\/code><\/p>\n
     <\/p>\n
    <\/p>\n
    \n
    \/\/ safeComparison.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <utility><\/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>cout <<<\/span> std::<\/span>boolalpha;\r\n\r\n    int<\/span> x =<\/span> -<\/span>3<\/span>;\r\n    unsigned<\/span> int<\/span> y =<\/span> 7<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> \"3 == 7:  \"<\/span> <<<\/span> std::<\/span>cmp_equal(x, y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"3 != 7:  \"<\/span> <<<\/span> std::<\/span>cmp_not_equal(x, y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"-3 < 7:  \"<\/span> <<<\/span> std::<\/span>cmp_less(x, y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"-3 <= 7: \"<\/span> <<<\/span> std::<\/span>cmp_less_equal(x, y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"-3 > 7:  \"<\/span> <<<\/span> std::<\/span>cmp_greater(x, y) <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"-3 => 7: \"<\/span> <<<\/span> std::<\/span>cmp_greater_equal(x, y) <<<\/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
    I also used in this program the equal and not equal operators.<\/p>\n
    Thanks to GCC 10, here is the expected result:<\/p>\n
    \"safeComparison\"<\/p>\n
    Invoking a comparison function with a non-integral value would cause a compile-time error.<\/p>\n
     <\/p>\n
    <\/p>\n
    \n
    \/\/ safeComparison2.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <utility><\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    double<\/span> x =<\/span> -<\/span>3.5<\/span>;             \/\/ (1)<\/span>\r\n    unsigned<\/span> int<\/span> y =<\/span> 7<\/span>;          \/\/ (2)<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> \"-3.5 < 7:  \"<\/span> <<<\/span> std::<\/span>cmp_less(x, y) <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    Trying to compare a double<\/code> (line (1)) and an unsigned int<\/code> (line (2)) gives the GCC 10 compiler a lengthy error message. Here is the crucial line of the error message:<\/p>\n
    \"safeComparison2\"The internal type-traits  __is_standard_integer failed. I was curious about what that means and looked it up in the GCC type-traits implementation on GitHub<\/a>. Here are the relevant lines from the header type-traits:<\/code><\/p>\n
     <\/p>\n
    <\/p>\n
    \n
    \/\/ Check if a type is one of the signed or unsigned integer types.<\/span>\r\n  template<\/span><<\/span>typename<\/span> _Tp><\/span>\r\n    using<\/span> __is_standard_integer\r\n      =<\/span> __or_<<\/span>__is_signed_integer<<\/span>_Tp><\/span>, __is_unsigned_integer<<\/span>_Tp>><\/span>;\r\n\r\n\/\/ Check if a type is one of the signed integer types.<\/span>\r\n  template<\/span><<\/span>typename<\/span> _Tp><\/span>\r\n    using<\/span> __is_signed_integer =<\/span> __is_one_of<<\/span>__remove_cv_t<\/span><<\/span>_Tp><\/span>,\r\n\t  signed<\/span> char<\/span>, signed<\/span> short<\/span>, signed<\/span> int<\/span>, signed<\/span> long<\/span>,\r\n\t  signed<\/span> long<\/span> long<\/span>\r\n\r\n\/\/ Check if a type is one of the unsigned integer types.<\/span>\r\n  template<\/span><<\/span>typename<\/span> _Tp><\/span>\r\n    using<\/span> __is_unsigned_integer =<\/span> __is_one_of<<\/span>__remove_cv_t<\/span><<\/span>_Tp><\/span>,\r\n\t  unsigned<\/span> char<\/span>, unsigned<\/span> short<\/span>, unsigned<\/span> int<\/span>, unsigned<\/span> long<\/span>,\r\n\t  unsigned<\/span> long<\/span> long<\/span>\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    __remove_cv_t<\/code> is the internal function of GCC to remove const<\/code> or volatile<\/code> from a type.<\/p>\n
    Maybe, you are now curious about what happens when you compare a double<\/code> and an unsigned int<\/code> the classical way.<\/p>\n
    Here is the modified program safeComparison2.cpp.<\/code><\/p>\n
    <\/p>\n
    \n
    \/\/ classicalComparison.cpp<\/span>\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    double<\/span> x =<\/span> -<\/span>3.5<\/span>;             \r\n    unsigned<\/span> int<\/span> y =<\/span> 7<\/span>;          \r\n\r\n    auto<\/span> res =<\/span> x <<\/span> y;     \/\/ true<\/span>\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    It works. The crucial unsigned int<\/code> is floating-point promoted<\/a> to double<\/code>. C++ Insights<\/a> shows the truth:<\/p>\n
    \"classicalComparision\"<\/p>\n
    After so many comparisons, I want to end this post with our new mathematical constants with C++20.<\/p>\n
    Mathematical Constants<\/h2>\n
     First, the constants require the header <numbers><\/code> and the namespace std::numbers<\/code>. The following tables give you the first overview. <\/code><\/code><\/p>\n
     \"constantsEng2\"\"constantsEng1\"<\/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
    The program mathematicConstants.cpp<\/code> applies the mathematical constants.<\/p>\n
    <\/p>\n
    \n
    \/\/ mathematicConstants.cpp<\/span>\r\n\r\n#include <iomanip><\/span>\r\n#include <iostream><\/span>\r\n#include <numbers><\/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>cout<<<\/span> std::<\/span>setprecision(10<\/span>);\r\n    \r\n    std::<\/span>cout <<<\/span> \"std::numbers::e: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>e <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::log2e: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>log2e <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::log10e: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>log10e <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::pi: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>pi <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::inv_pi: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>inv_pi <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"std::numbers::inv_sqrtpi: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>inv_sqrtpi <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::ln2: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>ln2 <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::sqrt2: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>sqrt2 <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::sqrt3: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>sqrt3 <<<\/span> std::<\/span>endl; \r\n    std::<\/span>cout <<<\/span> \"std::numbers::inv_sqrt3: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>inv_sqrt3 <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"std::numbers::egamma: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>egamma <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> \"std::numbers::phi: \"<\/span> <<<\/span>  std::<\/span>numbers::<\/span>phi <<<\/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
    Here is the output of the program with the MSVC compiler 19.27.<\/p>\n
     \"mathematicalConstants\"<\/p>\n
     <\/p>\n
    The mathematical constants are available for float<\/code>, double<\/code>, and long double<\/code>. Per-default double<\/code> is used, but you can also specify float<\/code> (std::numbers::pi_v<float><\/code>) or long double<\/code> (std::numbers::pi_v<long double><\/code>).<\/p>\n
    What’s next?<\/h2>\n
    C++20 offers more valuable utilities. For example, you can ask your compiler which C++ feature it supports, and can easily create functional objects with std::bind_front, <\/code>or perform different actions in a function whether the function runs a compile-time or at runtime.<\/p>\n<\/p>\n
     <\/p>\n
     <\/div>\n","protected":false},"excerpt":{"rendered":"
     When you compare signed and unsigned integers, you may not get the result you expect. Thanks to the six std::cmp_* functions, there is a cure in C++20.<\/p>\n","protected":false},"author":21,"featured_media":5945,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[],"class_list":["post-6030","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6030","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=6030"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6030\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5945"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6030"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6030"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6030"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}