{"id":592,"date":"2014-03-15T00:01:07","date_gmt":"2014-03-15T08:01:07","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=592"},"modified":"2014-03-08T08:58:26","modified_gmt":"2014-03-08T16:58:26","slug":"getting-shifty","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=592","title":{"rendered":"Getting Shifty"},"content":{"rendered":"

Something that you can do in the C language that C++ programmers cannot is employ the shift operators. These operators, <<<\/code> and >><\/code>, serve as I\/O operators in C++. In C, however, they can be used to manipulate values at the bit level in C, which is part of the C language’s mid-level heritage.
\n
\nWhen it comes to peeling information from a byte of storage, nothing beats the C language’s low-level operators. In concert with the bitwise logical operators: |<\/code>, &<\/code>, and ^<\/code>, you can use <<<\/code> and >><\/code> to manipulate data at the computer equivalent of the microscopic level. You can also do math.<\/p>\n

Back in my early programming days, I was an enthusiastic fan of Assembly language, which allows you to directly program a computer’s processor. Assembly has no functions. It has no operators. Everything you do in an Assembly program — everything<\/em> — must be coded from scratch. That includes the basic math operations multiplication and division.<\/p>\n

All processors handle basic addition, subtraction, and increment\/decrement operations. Today’s processors have instructions for multiplication or division, but that wasn’t common back in the early days.<\/p><\/blockquote>\n

The following code demonstrates how multiplication can be done in the C language without using the *<\/code> multiplication operator. Just as with programming a processor directly by using Assembly language, the operations performed in this code are all at the bit level:<\/p>\n

\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    int x,bytwo,byeight,byten;\r\n\r\n    printf(\"Type an integer: \");\r\n    scanf(\"%d\",&x);\r\n\r\n    bytwo = x << 1;\r\n    byeight = x << 3;\r\n    byten = bytwo + byeight;\r\n\r\n    printf(\"%d x 10 = %d\\n\",x,byten);\r\n\r\n    return(0);\r\n}<\/pre>\n
Here’s a sample run:<\/p>\n
Type an integer: 489
\n489 x 10 = 4890<\/code><\/p>\n
It even works on negative numbers:<\/p>\n
Type an integer: -30
\n-30 x 10 = -300<\/code><\/p>\n
The left-shift operator <<<\/code> is used twice in the above code, first at Line 10 and then at Line 11.<\/p>\n
bytwo = x << 1;<\/code><\/p>\n
The effect of this code is to double the value in variable x<\/code>. The bits are shifted one notch to the left, which in binary terms multiplies that value by two. This bit-shift operation is extremely fast because the processor can manipulate data directly in that manner. You could almost say the processor enjoys<\/em> performing that operation.<\/p>\n
byeight = x << 3;<\/code><\/p>\n
This statement shifts the value in x<\/code> three notches to the left at the binary level. The effect is to multiply the value by 8. Conveniently, 23<\/sup> is 8, which is why the value 3 is used.<\/p>\n
With the original value x<\/code> multiplied by 2 and stored in variable bytwo<\/code>, and the original value of x<\/code> multiplied by 8 and stored in the variable byeight<\/code>, the result of bytwo<\/code> and byeight<\/code> would be to multiply the value x<\/code> by 10. That’s what the program does. And that’s exactly how the operation would have been performed at the low level in Assembly language.<\/p>\n
The only problem you get into is with very large integers, in which case the <<<\/code> operator shifts the left-most bit in a value off into oblivion. But for small values, this trick is quite effective.<\/p>\n","protected":false},"excerpt":{"rendered":"
Back in the old days, computer memory was tight and processors were slow. If you wanted to code quickly, you had to eschew higher level math functions and get down and dirty with the processor. 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-592","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\/592","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=592"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/592\/revisions"}],"predecessor-version":[{"id":615,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/592\/revisions\/615"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=592"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=592"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=592"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}