{"id":4685,"date":"2021-04-03T00:01:05","date_gmt":"2021-04-03T07:01:05","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=4685"},"modified":"2021-04-10T08:30:08","modified_gmt":"2021-04-10T15:30:08","slug":"sign-bits","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=4685","title":{"rendered":"Sign Bits"},"content":{"rendered":"

I recall the math class where negative numbers were introduced. I was appalled. From Star Trek<\/em>, I easily accepted the concept of antimatter, but the notion of negative values deeply offended me.
\n
\nAs I learned about computers, negative binary numbers blew me away. In a clutch of bits, which is essentially how values on a computer are stored, how can you have something negative? I mean, binary is just one and zero, right? Where is the negative?<\/p>\n

The answer is the sign bit<\/em>.<\/p>\n

In a binary value, the left-most bit is the sign bit — for signed<\/em> integer values. The unsigned<\/em> integer type values treat the bit as part of the number. But for a signed<\/em> value, the bit is 0 for a positive value or 1 for a negative value, as crudely illustrated in Figure 1.<\/p>\n

\"\"<\/a>

Figure 1. How the computer interprets signed versus unsigned values.<\/p><\/div>\n

In Figure 1, the first value shown is -1, binary 11111111<\/code> for a signed<\/em> byte-sized (char<\/em>) integer value. For the unsigned<\/em> data type, the value shown is 255. The latter value makes more sense to me. Therefore, to best illustrate how this nonsense works, a program is in order.<\/p>\n

2021_04_03-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    signed char a = 0;\r\n    int x;\r\n\r\n    for( x=0; x<256; x++ )\r\n    {\r\n        printf(\"%d\\n\",a);\r\n        a++;\r\n    }\r\n\r\n    return(0);\r\n}<\/pre>\n
This code loops through char values from 0 to 256. But because variable a<\/code> is signed<\/em>, once it huts the value where the sign bit is flipped from 0 to 1, negative values are output. Here is the interesting part of that output:<\/p>\n
123
\n124
\n125
\n126
\n127
\n-128
\n-127
\n-126
\n-125<\/code><\/p>\n
After 127 (binary 01111111<\/code>) the next value is -128 (binary 10000000<\/code>). Below, I’ve modified the code to include my binbin()<\/em> function, which is showcased in my C books for outputting binary values:<\/p>\n
2021_04_03-Lesson-b.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nchar *binbin(unsigned char n)\r\n{\r\n    static char bin[9];\r\n    int x;\r\n\r\n    for(x=0;x<8;x++)\r\n    {\r\n        bin[x] = n & 0x80 ? '1' : '0';\r\n        n <<= 1;\r\n    }\r\n    bin[x] = '\\0';\r\n    return(bin);\r\n}\r\n\r\nint main()\r\n{\r\n    signed char a = 0;\r\n    int x;\r\n\r\n    for( x=0; x<256; x++ )\r\n    {\r\n        printf(\"%d\\t%s\\n\",a,binbin(a));\r\n        a++;\r\n    }\r\n\r\n    return(0);\r\n}<\/pre>\n
The code runs the same, but with an additional column in the output. Again, here is the interesting part:<\/p>\n
123     01111011
\n124     01111100
\n125     01111101
\n126     01111110
\n127     01111111
\n-128    10000000
\n-127    10000001
\n-126    10000010
\n-125    10000011<\/code><\/p>\n
As soon as the 8th bit (for a char<\/em>) flips, the values output are negative. Further, they flow upward as variable a<\/code> increments. Eventually, the value returns to zero.<\/p>\n
The sign bit is significant for signed<\/em> integer variables. In fact, you can force-flip the bit so that values turn negative, as demonstrated in the following code:<\/p>\n
2021_04_03-Lesson-c.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nchar *binbin(unsigned char n)\r\n{\r\n    static char bin[9];\r\n    int x;\r\n\r\n    for(x=0;x<8;x++)\r\n    {\r\n        bin[x] = n & 0x80 ? '1' : '0';\r\n        n <<= 1;\r\n    }\r\n    bin[x] = '\\0';\r\n    return(bin);\r\n}\r\n\r\nint main()\r\n{\r\n    signed char a = 0;\r\n    int x;\r\n\r\n    for( x=0; x<256; x++ )\r\n    {\r\n        a |= 0x80;\r\n        printf(\"%d\\t%s\\n\",a,binbin(a));\r\n        a++;\r\n    }\r\n\r\n    return(0);\r\n}<\/pre>\n
This code is identical to the preceding example, save for a new Line 24: a |= 0x80<\/code>. This statement sets the first bit in the byte to 1, which makes all the output negative. Again, the same chunk of output from the sample run as shown earlier:<\/p>\n
-5     11111011
\n-4     11111100
\n-3     11111101
\n-2     11111110
\n-1     11111111
\n-128    10000000
\n-127    10000001
\n-126    10000010
\n-125    10000011<\/code><\/p>\n
With the sign bit set, the first part of the output shows negative values, from -128 on up to -1. Then the loop starts over again at -128.<\/p>\n
By the way, 10000000<\/code> is interpreted as -128 and not “negative zero.” Unlike other programming languages, C lacks an equivalent for negative zero. I explore this notion in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
Negative binary values are quite clever in their implementation. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-4685","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4685","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4685"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4685\/revisions"}],"predecessor-version":[{"id":4719,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4685\/revisions\/4719"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4685"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4685"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4685"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}