{"id":1433,"date":"2015-02-01T07:32:20","date_gmt":"2015-01-31T21:32:20","guid":{"rendered":"http:\/\/brnz.org\/hbr\/?p=1433"},"modified":"2015-02-01T07:32:20","modified_gmt":"2015-01-31T21:32:20","slug":"what-is-1u","status":"publish","type":"post","link":"https:\/\/brnz.org\/hbr\/?p=1433","title":{"rendered":"What is -1u?"},"content":{"rendered":"

In C++, what exactly is -1u<\/strong>?<\/p>\n

It doesn’t seem like it should be difficult to answer — it’s only three characters: –<\/strong>, 1<\/strong>, and u<\/strong>. And, knowing a little bit about C++, it seems like that’ll be (-1)<\/strong> negative one with that u<\/strong>\u00a0making ((-1)u)<\/strong> an\u00a0unsigned int<\/strong>. Right?<\/p>\n

To be more specific, on an architecture where int<\/strong> is a 32 bit type, and negative numbers are represented using two’s complement<\/a> (i.e. just about all of them), negative one has the binary value 11111111111111111111111111111111. And converting that to unsigned int<\/strong> should … still be those same thirty two ones. Shouldn’t it?<\/p>\n

I can test that hypothesis! Here’s a program that will answer the question once and for all:<\/p>\n

#include <stdio.h>\r\n#include <type_traits>\r\n\r\nint main()\r\n{\r\n static_assert(std::is_unsigned<decltype(-1u)>::value, \r\n               \"actually not unsigned\");\r\n printf(\"-1u is %zu bytes, with the value %#08x\\n \", \r\n        sizeof -1u, -1u);\r\n}\r\n<\/pre>\n
Compile and run it like this:<\/span><\/p>\n
g++ -std=c++11 minus_one_u.cpp -o minus_one_u && minus_one_u\r\n<\/pre>\n
If I do that, I see the following output:<\/span><\/p>\n
-1u is 4 bytes, with the value 0xffffffff<\/pre>\n
I’m using -std=c++11<\/strong> to be able to use\u00a0std::is_unsigned<\/strong>, decltype<\/strong> and static_assert<\/strong> which combine to assure me that (-1u)<\/strong> is actually unsigned as the program wouldn’t have compiled if that wasn’t the case.\u00a0And the output shows the\u00a0result I had hoped for: it’s a four byte value, containing\u00a00xffffffff<\/strong> (which is the same as that string of thirty two ones I was looking for).<\/p>\n
I have now proven that -1u<\/strong> means “convert -1<\/strong>\u00a0to an unsigned int<\/strong>.”\u00a0Yay me!<\/p>\n
Not so much.<\/h3>\n
It just so happened that I was reading about integer literals in a recent draft of the ISO C++ standard. Here’s the part of the standard that describes the format of decimal integer literals:<\/p>\n
2.14.2 Integer literals
\n1 An integer literal<\/em> is a sequence of digits that has no period or exponent part, with optional separating single\u00a0quotes that are ignored when determining its value. An integer literal may have a prefix that specifies\u00a0its base and a suffix that specifies its type. The lexically first digit of the sequence of digits is the most\u00a0significant. A decimal<\/em> integer literal (base ten) begins with a digit other than 0 and consists of a sequence\u00a0of decimal digits.<\/p><\/blockquote>\n
Can you see where it describes negative integer literals?<\/p>\n
I can’t see where it describes negative integer literals.<\/p>\n
Oh.<\/p>\n
I though -1u<\/b>\u00a0was ((-1)u)<\/strong>.\u00a0<\/strong>I was wrong. Integer literals do not work that way.<\/p>\n
Obviously -1u<\/strong> didn’t just stop producing an unsigned int<\/strong> with the value 0xffffffff <\/strong>(the program proved it!!1), but the reason it has that value is not the reason I thought.<\/p>\n
So, what is -1u<\/strong>?<\/p>\n
The standard says\u00a0that 1u<\/b>\u00a0is an integer literal. So now I need to work out exactly what that –<\/strong>\u00a0is doing. What does it mean to negate 1u<\/strong>? Back to the standard I go.<\/p>\n
5.3.1 Unary operators
\n8\u00a0The operand of the unary – operator shall have arithmetic or unscoped enumeration type and the result\u00a0is the negation of its operand. Integral promotion is performed on integral or enumeration operands. The\u00a0negative of an unsigned quantity is computed by subtracting its value from 2n<\/sup><\/em>, where n<\/em> is the number of\u00a0bits in the promoted operand. The type of the result is the type of the promoted operand.<\/p><\/blockquote>\n
I feel like I’m getting closer to some real answers.<\/p>\n
So there’s a numerical operation to apply to this thing. But first, this:<\/p>\n
Integral promotion is performed on integral or enumeration operands.<\/p><\/blockquote>\n
Believe me when I tell you that this section changes nothing and you should skip it.<\/h3>\n
I have an integral operand (1u<\/strong>),\u00a0so integral promotion must be performed. Here is the part of the standard that deals with that:<\/p>\n
4.5\u00a0Integral promotions
\n1 A prvalue of an integer type other than bool, char16_t, char32_t, or wchar_t whose integer conversion\u00a0rank (4.13) is less than the rank of int can be converted to a prvalue of type int if int can represent all\u00a0the values of the source type; otherwise, the source prvalue can be converted to a prvalue of type unsigned\u00a0int.<\/p><\/blockquote>\n
I’m going to cut a corner here: integer literals\u00a0are prvalues, but I couldn’t find a place in the standard that explicitly declares this to be the case. It does seem pretty clear from 3.10 that they can’t be anything else. This page<\/a> gives a good rundown on C++ value categories, and does\u00a0state that integer literals are prvalues, so let’s go with that.<\/p>\n
If\u00a01u<\/strong> is a prvalue, and its type is unsigned int<\/strong>, I can collapse the standard text a little:<\/p>\n
4.5 Integral promotions (prvalue edition)
\nA value of an integer type whose integer conversion\u00a0rank (4.13) is less than the rank of int …<\/p><\/blockquote>\n
and I’m going to stop right there. Conversion rank what now? To 4.13!<\/p>\n
4.13 Integer conversion rank
\n1 Every integer type has an integer conversion rank<\/em> defined as follows:<\/p><\/blockquote>\n
Then a list of ten different rules, including this one:<\/p>\n
\u2014 The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type.<\/p><\/blockquote>\n
Without knowing more about conversion ranks, this rule gives me enough information to determine what 4.5 means for unsigned int<\/strong> values: unsigned int<\/strong>\u00a0has the same rank as\u00a0int<\/strong>.\u00a0So I can rewrite 4.5 one more time like this:<\/p>\n
4.5\u00a0Integral promotions (unsigned int edition)
\n1\u00a0[This space intentionally left blank]<\/p><\/blockquote>\n
Integral promotion of an unsigned int<\/strong> value doesn’t change a thing.<\/p>\n
Where was I?<\/h3>\n
Now I can rewrite 5.3.1 with the knowledge that 1u<\/strong>\u00a0requires no integral promotion:<\/p>\n
5.3.1 Unary operators (unsigned int operand edition)
\n8\u00a0The [result of] the unary – operator … is the negation of its operand. The\u00a0negative of an unsigned quantity is computed by subtracting its value from 2n<\/sup><\/em>, where n<\/em> is the number of\u00a0bits in the promoted operand. The type of the result is the type of the operand.<\/p><\/blockquote>\n
And, at long last, I\u00a0get to do the negating. For an unsigned value that means:<\/p>\n
[subtract] its value from 2n<\/sup><\/em>, where n<\/em> is the number of\u00a0bits in the promoted operand.<\/p><\/blockquote>\n
My unsigned int<\/strong>\u00a0has 32 bits, so that would be 232<\/sup>\u00a0– 1<\/em>. Which in hexadecimal looks something like this:<\/p>\n
  0x100000000\r\n- 0x000000001<\/span>\r\n  0x0ffffffff<\/pre>\n
But that leading zero I’ve left on the result goes away because<\/p>\n
The type of the result is the type of the (promoted) operand.<\/p><\/blockquote>\n
And I am now certain that I know how\u00a0-1u<\/strong>\u00a0becomes an\u00a0unsigned int<\/strong> with the value 0xffffffff<\/strong>. In fact, it’s not even dependent on having a platform that uses two’s complement \u00a0— nothing in the conversion relies on that.<\/p>\n
But… when could this possibly ever matter?<\/h3>\n
For -1u<\/strong>?\u00a0<\/strong>I don’t see this ever causing actual problems. There are situations that arise from the way that C++ integer literals are defined that can cause surprises (i.e. bugs) for the unsuspecting programmer.<\/p>\n
There is a particular case described in the documentation for\u00a0Visual C++ compiler warning C4146<\/a>, but I think the rationale for that warning is wrong (or, at least, imprecise), but not because of something I’ve covered in this article. As I’ve already written far too many words about these three characters, I’ll keep that discussion\u00a0for some time in the future.<\/p>\n","protected":false},"excerpt":{"rendered":"
In C++, what exactly is -1u? It doesn’t seem like it should be difficult to answer — it’s only three characters: –, 1, and u. And, knowing a little bit about C++, it seems like that’ll be (-1) negative one with that u\u00a0making ((-1)u) an\u00a0unsigned int. Right? To be more specific, on an architecture where … Continue reading “What is -1u?”<\/span><\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[5,26],"tags":[],"_links":{"self":[{"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=\/wp\/v2\/posts\/1433"}],"collection":[{"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1433"}],"version-history":[{"count":17,"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=\/wp\/v2\/posts\/1433\/revisions"}],"predecessor-version":[{"id":1450,"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=\/wp\/v2\/posts\/1433\/revisions\/1450"}],"wp:attachment":[{"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1433"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1433"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/brnz.org\/hbr\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1433"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}