{"id":23240,"date":"2023-12-17T12:08:25","date_gmt":"2023-12-17T12:08:25","guid":{"rendered":"https:\/\/linuxways.net\/?p=23240"},"modified":"2024-03-25T02:10:29","modified_gmt":"2024-03-25T02:10:29","slug":"bitwise-operators-c-language","status":"publish","type":"post","link":"https:\/\/linuxways.net\/de\/scripting\/bitwise-operators-c-language\/","title":{"rendered":"Bitwise Operators in C Language"},"content":{"rendered":"
In this Linux Ways article, you’ll learn how to use the bitwise operators in C. We’ll show you a section that is dedicated to each of these operators where you’ll see their symbol, their expression, a truth table describing their logic, and a practical example with code snippets and images that show their usage.<\/p>\n

You will also see how to assign the values in binary notation and we will show you the code of a function that displays in this notation the value of the variables that we will use in different examples.<\/p>\n

You’ll also learn about short-circuit logic or minimum evaluation in bit-by-bit logic operations, so you’ll have a comprehensive knowledge and know which the best option for each need is when you need to perform the bitwise operations in C.<\/p>\n

<\/a>Bitwise Operators in the C Language<\/h2>\n

Bitwise operations can be logical or bit-shifting. The logical operations of this type are performed bit by bit on the binary basis of the variable. For example, in a logical operation between variables \u201ca\u201d and \u201cb\u201d that returns the result in \u201cc\u201d, the bit \u201c0\u201d of variable \u201ca\u201d operates on bit \u201c0\u201d of variable \u201cb\u201d and returns the result in bit \u201c0\u201d of variable \u201cc\u201d. In the following, we will see a table of bitwise operations and their operators in C:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
Operation<\/strong><\/td>\nOperator<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
NOT<\/strong><\/td>\n~<\/strong><\/td>\nReturns the inverted value of a variable.<\/td>\n<\/tr>\n
OR<\/strong><\/td>\n|<\/strong><\/td>\nPerform an OR operation between two variables.<\/td>\n<\/tr>\n
AND<\/strong><\/td>\n&<\/strong><\/td>\nPerform an AND operation between two variables.<\/td>\n<\/tr>\n
XOR<\/strong><\/td>\n^ <\/strong><\/td>\nPerform an XOR operation between two variables.<\/td>\n<\/tr>\n
Left shift<\/strong><\/td>\n<<<\/strong><\/td>\nShift n<\/em><\/strong> bits to the left.<\/td>\n<\/tr>\n
Right shift<\/strong><\/td>\n>><\/strong><\/td>\nShift n<\/em><\/strong> bits to the right.<\/td>\n<\/tr>\n
AND<\/strong><\/td>\n&&<\/strong><\/td>\nShort circuit AND operation.<\/td>\n<\/tr>\n
OR<\/strong><\/td>\n||<\/strong><\/td>\nShort circuit OR operation.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The logical NOT and shift operations are unary, which means that they operate on a single variable while the AND, OR, and XOR operations operate on two.<\/p>\n

The bitwise operations are often used, for example, to mask multiple flags in a single variable which is then used as a flag input argument in functions.<\/p>\n

To better understand the bitwise operations that we’ll see in this article, the next section provides tips to help you easily assign and display the values on the screen using binary notation.<\/p>\n

<\/a>How to Assign and View the Values with Binary Notation in the C Language<\/h2>\n

To assign the binary values to the variables in the C language, we must prefix the binary value with the notation base which is \u201c0b\u201d. In the following, we will see a fragment that declares the variable \u201ca\u201d of type unsigned char and assigns it with the value of 00011000.<\/p>\n

unsigned<\/span> char<\/span> a =<\/span> 0b00011000<\/span>;<\/span><\/div><\/div>\n

Now, let’s look at how we can make these values visible in the command console. The code that we see in the following belongs to a function that converts the unsigned char values that are sent in its input argument into binary notation strings and displays them on the screen:<\/p>\n

void<\/span> tobin (<\/span>unsigned<\/span> char<\/span> a)<\/span>;<\/span>
\n
\nvoid<\/span> tobin (<\/span>unsigned<\/span> char<\/span> a)<\/span>
\n{<\/span>
\n   unsigned<\/span> char<\/span> mask=<\/span> 0b10000000<\/span>;<\/span>
\n   unsigned<\/span> char<\/span> c;<\/span>
\n   for<\/span> (<\/span>int<\/span> bit=<\/span>0<\/span>;<\/span> bit!=<\/span>8<\/span>;<\/span> bit++<\/span>)<\/span>
\n     {<\/span>
\n      c =<\/span> a &<\/span> mask;<\/span>
\n      if<\/span> (<\/span> c==<\/span> 0<\/span> )<\/span>
\n         printf<\/span><\/a>(<\/span> "0"<\/span> )<\/span>;<\/span>
\n      else<\/span>
\n         printf<\/span><\/a>(<\/span> "1"<\/span> )<\/span>;<\/span>
\n      mask =<\/span> mask >><\/span> 1<\/span>;<\/span>
\n      c =<\/span> 0<\/span>;<\/span>
\n     }<\/span>  printf<\/span><\/a> (<\/span>"\\n<\/span>"<\/span>)<\/span>;<\/span>
\n  }<\/span><\/div><\/div>\n

We store this simple function in a file named \u201ctobin.c\u201d in the directory where the main file is located, and it will help us see the results in binary notation of the examples that we will see in this article.<\/p>\n

To use the function, we need to include it to the main file as follows:<\/p>\n

#include "tobin.c"<\/span><\/div><\/div>\n

\nThe \u201c~\u201d Operator and Logical Bitwise NOT Operations<\/h2>\n

The operator that is used to perform the logical NOT operations is the \u201c~\u201d symbol. In the following, we see the expression that is used to perform this operations:<\/p>\n

c =<\/span>~ a;<\/span><\/div><\/div>\n

The NOT operation inverts the value of the bit, giving 1 if the operated bit is 0, and 0 if it is 1. This type of operation is used to get the complement of a value. In the following, we see the truth table for this operation:<\/p>\n\n\n\n\n\n
a<\/strong><\/td>\n~<\/strong><\/td>\n=<\/strong><\/td>\n<\/tr>\n
0<\/td>\n~<\/strong><\/td>\n1<\/td>\n<\/tr>\n
1<\/td>\n~<\/strong><\/td>\n0<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

How to Perform a NOT Operation in the C Language<\/h2>\n

In this example, we will create the variables \u201ca\u201d and \u201cc\u201d, both of type unsigned char. The variable \u201cc\u201d stores the result of the NOT operation of the variable \u201ca\u201d. The binary value that we assign to this variable is 0b00011000 whose conversion to an integer is 24.<\/p>\n

Then, we execute the NOT operation with the following expression:<\/p>\n

c =<\/span>~ a<\/div><\/div>\n

Using the tobin() function, we display the original and resulting value on the screen in binary format. In the following, we see the code for this operation:<\/p>\n

#include <stdio.h><\/span>
\n#include <stdlib.h><\/span>
\n#include <unistd.h><\/span>
\n#include "tobin.c<\/span>
\n
\nint<\/span> main(<\/span>)<\/span>
\n
\n{<\/span>
\n
\nunsigned<\/span> char<\/span> a =<\/span> 0b00011000<\/span>;<\/span>
\n
\nunsigned<\/span> char<\/span> c;<\/span>
\n
\ntobin(<\/span>a)<\/span>;<\/span>
\n
\nc =<\/span>~a;<\/span>
\n
\ntobin(<\/span>c)<\/span>;<\/span>
\n
\n}<\/span><\/div><\/div>\n

In the following figure, we see the execution of this code, returning the value of \u201ca\u201d and the result of the operation in \u201cc\u201d:<\/p>\n

<\/p>\n

<\/a>The \u201c&\u201d Operator and Logical AND Operations in the C Language<\/h2>\n

The operator that is used to perform the logical AND operations is the \u201c&<\/em>\u201d symbol.<\/p>\n

In the following, we see the expression that is used to perform these logical operations between variables \u201ca\u201d and \u201cb\u201d:<\/p>\n

c =<\/span> a &<\/span> b;<\/span><\/div><\/div>\n

The AND operation returns 1 only when bits \u201ca\u201d and \u201cb\u201d are equal to 1, and 0 in other cases. In the following, we see the truth table for the AND operation:<\/p>\n\n\n\n\n\n\n\n
a<\/strong><\/td>\n&<\/strong><\/td>\nb<\/strong><\/td>\n=<\/strong><\/td>\n<\/tr>\n
0<\/td>\n&<\/strong><\/td>\n0<\/td>\n0<\/td>\n<\/tr>\n
0<\/td>\n&<\/strong><\/td>\n1<\/td>\n0<\/td>\n<\/tr>\n
1<\/td>\n&<\/strong><\/td>\n0<\/td>\n0<\/td>\n<\/tr>\n
1<\/td>\n&<\/strong><\/td>\n1<\/td>\n1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The logical AND operations are commonly used to clear the bits from a flag mask. For example, if we want to set the bit one of a mask to zero, we perform this operation between the mask and the \u201c0b1111101\u201d value. In this way, bit one is set to 0 while the rest retains its previous state.<\/p>\n

<\/a>How to Perform a Logical AND Operation in the C Language<\/h2>\n

In this example, we will see how to perform the AND operation between variables \u201ca\u201d and \u201cb\u201d and store the result in variable \u201cc\u201d.<\/p>\n

We assign the \u201c0b11101111\u201d to variable \u201ca\u201d and the \u201c0b01010011\u201d value to variable \u201cb\u201d. Then, we perform the AND operation with the \u201c&\u201d operator. To display the values and results in binary notation, we call the tobin() function. In the following, we see the code for this example:<\/p>\n

#include <stdio.h><\/span>
\n#include <stdlib.h><\/span>
\n#include <unistd.h><\/span>
\n#include "tobin.c"<\/span>
\n
\nvoid<\/span> main(<\/span>)<\/span>
\n
\n{<\/span>
\n
\nunsigned<\/span> char<\/span> a =<\/span> 0b11101111<\/span>;<\/span>
\n
\nunsigned<\/span> char<\/span> b =<\/span> 0b01010011<\/span>;<\/span>
\n
\nunsigned<\/span> char<\/span> c;<\/span>
\n
\ntobin(<\/span>a)<\/span>;<\/span>
\n
\ntobin(<\/span>b)<\/span>;<\/span>
\n
\nprintf<\/span><\/a> (<\/span>"--------\\n<\/span>"<\/span>)<\/span>;<\/span>
\n
\nc =<\/span> a &<\/span> b;<\/span>
\n
\ntobin(<\/span>c)<\/span>;<\/span>
\n
\n}<\/span><\/div><\/div>\n

The image that we see in the following shows the execution of this code:<\/p>\n

<\/p>\n

As we can see, using the AND operations, we can clear the bits from a mask, this being the method to deselect the flags in variables that group several of them.<\/p>\n

<\/a>The \u201c|\u201dOperator and Logical OR Operations<\/h2>\n

The operator to perform the logical OR operations is the \u201c|\u201d symbol. In the following, we see the expression that is used to perform this logical operations between bits \u201ca\u201d and \u201cb\u201d:<\/p>\n

c =<\/span> a |<\/span> b;<\/span><\/div><\/div>\n

The OR operation results in 1 if bit \u201ca\u201d or bit \u201cb\u201d or both are equal to 1 and 0 if bit \u201ca\u201d and bit \u201cb\u201d are both equal to 0. In the following, we see the truth table for the OR operation:<\/p>\n\n\n\n\n\n\n\n
a<\/strong><\/td>\n|<\/strong><\/td>\nb<\/strong><\/td>\n=<\/strong><\/td>\n<\/tr>\n
0<\/td>\n|<\/strong><\/td>\n0<\/td>\n0<\/td>\n<\/tr>\n
0<\/td>\n|<\/strong><\/td>\n1<\/td>\n1<\/td>\n<\/tr>\n
1<\/td>\n|<\/strong><\/td>\n0<\/td>\n1<\/td>\n<\/tr>\n
1<\/td>\n|<\/strong><\/td>\n1<\/td>\n1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The bitwise OR operation is often used to create the flag masks in variables, grouping several of them.<\/p>\n

<\/a>How to Perform an OR Operation in the C Language<\/h2>\n

 <\/p>\n

In this example, we will show you how to perform an OR operation between variables \u201ca\u201d and \u201cb\u201d, both of type unsigned char, and store the result in the variable \u201cc\u201d. We will assign the \u201c0b000011\u201d value to variable \u201ca\u201d and the \u201c0b010101\u201d value to variable \u201cb\u201d. Then, we perform the OR operation with the \u201c|\u201d operator.<\/p>\n

Then, we call the tobin() function to see the status of the variables and its result. In the following, we see the code for this example:<\/p>\n

#include <stdio.h><\/span>
\n
\n#include <stdlib.h><\/span>
\n
\n#include <unistd.h><\/span>
\n
\n#include "tobin.c"<\/span>
\n
\nvoid<\/span> main(<\/span>)<\/span>
\n
\n{<\/span>
\n
\nunsigned<\/span> char<\/span> a =<\/span> 0b00000011<\/span>;<\/span>
\n
\nunsigned<\/span> char<\/span> b =<\/span> 0b01010101<\/span>;<\/span>
\n
\nunsigned<\/span> char<\/span> c;<\/span>
\n
\ntobin(<\/span>a)<\/span>;<\/span>
\n
\ntobin(<\/span>b)<\/span>;<\/span>
\n
\nprintf<\/span><\/a> (<\/span>"--------\\n<\/span>"<\/span>)<\/span>;<\/span>
\n
\nc =<\/span> a |<\/span> b;<\/span>
\n
\ntobin(<\/span>c)<\/span>;<\/span>
\n
\n}<\/span><\/div><\/div>\n

The image that we see in the following shows the execution of this code:<\/p>\n

<\/p>\n

As we see, the use of OR operations is the method to configure the flags in variables by grouping several of them.<\/p>\n

<\/a>The \u201c^\u201d Operator and Logical XOR Operations<\/h2>\n

The operator to carry out the XOR logical operations is the \u201c|\u201d symbol.<\/p>\n

In the following, we see the expression that is used to perform the XOR logical operations between bits \u201ca\u201d and \u201cb\u201d:<\/p>\n

c =<\/span> a ^<\/span> b;<\/span><\/div><\/div>\n

The XOR operation results in 1 if bit \u201ca\u201d or bit \u201cb\u201d are equal to 1 and 0. But it results in 0 if both are equal to 0 or equal to 1. In the following, we see the truth table for the XOR operation:<\/p>\n\n\n\n\n\n\n\n
a<\/strong><\/td>\n^ <\/strong><\/td>\nb<\/strong><\/td>\n=<\/strong><\/td>\n<\/tr>\n
0<\/td>\n^ <\/strong><\/td>\n0<\/td>\n0<\/td>\n<\/tr>\n
0<\/td>\n^ <\/strong><\/td>\n1<\/td>\n1<\/td>\n<\/tr>\n
1<\/td>\n^ <\/strong><\/td>\n0<\/td>\n1<\/td>\n<\/tr>\n
1<\/td>\n^ <\/strong><\/td>\n1<\/td>\n0<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

<\/a>How to Perform a XOR Operation in the C Language<\/h2>\n

 <\/p>\n

In this example, we will show you how to perform a XOR operation between variables \u201ca\u201d and \u201cb\u201d, both of type unsigned char, and store the result in variable \u201cc\u201d. We assign the \u201c0b11010011\u201d value to the variable \u201ca\u201d and the \u201c0b01010101\u201d value to \u201cb\u201d. Then, we operate the variables with the \u201c^\u201d operator and show the state of it with the tobin() function. In the following, you can see the code for this example:<\/p>\n

#include <stdio.h><\/span>
\n
\n#include <stdlib.h><\/span>
\n
\n#include <unistd.h><\/span>
\n
\n#include "tobin.c"<\/span>
\n
\nvoid<\/span> main(<\/span>)<\/span>
\n
\n{<\/span>
\n
\nunsigned<\/span> char<\/span> a =<\/span> 0b11010011<\/span>;<\/span>
\n
\nunsigned<\/span> char<\/span> b =<\/span> 0b01010101<\/span>;<\/span>
\n
\nunsigned<\/span> char<\/span> c;<\/span>
\n
\nprintf<\/span><\/a> (<\/span>"--------\\n<\/span>"<\/span>)<\/span>;<\/span>
\n
\nc =<\/span> a ^<\/span> b;<\/span>
\n
\ntobin(<\/span>a)<\/span>;<\/span>
\n
\ntobin(<\/span>b)<\/span>;<\/span>
\n
\ntobin(<\/span>c)<\/span>;<\/span>
\n
\n}<\/span><\/div><\/div>\n

The image that we see in the following shows the execution of this code:<\/p>\n

<\/strong><\/p>\n

As we can see, the XOR operation behaves like an OR operation, except in cases where \u201ca\u201d and \u201cb\u201d are both equal to 1.<\/p>\n

<\/a>The \u201c<<\u201d and \u201c>>\u201d Operators for Bit Shifting<\/h2>\n

The \u201c< <\u201d and \u201c> >\u201d operators shift a number \u201cn\u201d bits of a variable to the left or right and fill the empty places with zeros.<\/p>\n

The following is the expression that is used to perform the n-bit shifts to the left and to the right:<\/p>\n

c =<\/span> a <<<\/span> n;<\/span>
\n
\nc =<\/span> a >><\/span> n;<\/span><\/div><\/div>\n

\n

How to Shift the Bits with the \u201c<<\u201d and \u201c>>\u201d Operators in the C Language<\/h2>\n

In this example, we will declare the variable \u201ca\u201d and assign it with the \u201c0b0011000\u201d value. Then, we will rotate two bits to the left and display the result on the screen with the tobin() function. Then, we move the bits again, but four positions to the right, and display the result. In the following, we can see the code for this example:<\/p>\n

#include <stdio.h><\/span>
\n
\n#include <stdlib.h><\/span>
\n
\n#include <unistd.h><\/span>
\n
\n#include "tobin.c"<\/span>
\n
\nvoid<\/span> main(<\/span>)<\/span>
\n
\n{<\/span>
\n
\nunsigned<\/span> char<\/span> a =<\/span> 0b00011000<\/span>;<\/span>
\n
\ntobin(<\/span>a)<\/span>;<\/span>
\n
\na =<\/span> a <<<\/span> 2<\/span>;<\/span>
\n
\ntobin(<\/span>a)<\/span>;<\/span>
\n
\na =<\/span> a >><\/span> 4<\/span>;<\/span>
\n
\ntobin(<\/span>a)<\/span>;<\/span>
\n
\n}<\/span><\/div><\/div>\n

The image that we see in the following shows the execution of this code:<\/p>\n

<\/p>\n

<\/a>
\nLogical Short Circuit Operations in the C Language<\/h2>\n

The bitwise operations are often used as input conditions in \u201cif\u201d conditions or even as escape conditions in loops. In these cases, we can perform a simple or compound bitwise operation.<\/p>\n

When we use the compound operations, there are cases where the first expression determines the final result independently of the result of the other operations. We can see this in the following expression:<\/p>\n

c =<\/span> (<\/span> a &<\/span> b )<\/span> &<\/span> (<\/span> d &<\/span> e )<\/span><\/div><\/div>\n

Now, we replace the variables with bit values:<\/p>\n

c =<\/span> (<\/span> 0<\/span> &<\/span> 1<\/span> )<\/span> &<\/span> (<\/span> 1<\/span> &<\/span> 1<\/span> )<\/span><\/div><\/div>\n

In this case, the result in \u201cc” is defined by the result =0 of the AND operation between \u201ca\u201d and \u201cb\u201d, independent of the result of the second operation.<\/p>\n

The same happens with the following OR operation:<\/p>\n

c =<\/span> (<\/span> 0<\/span> |<\/span> 1<\/span> )<\/span> |<\/span> (<\/span> 1<\/span> &<\/span> 1<\/span> )<\/span><\/div><\/div>\n

In this expression, the result of the OR operation between \u201ca\u201d and \u201cb\u201d is equal to 1, which is why it also determines the result in \u201cc\u201d. While the result of the second operation has no influence on the final result.<\/p>\n

For these cases, there is the possibility of performing the short-circuit operations. In this type of operation, the first expression is analyzed. If the result determines the final result, the program ignores the other expressions.<\/p>\n

To perform the short-circuit operations, the double operators of the operation to be performed are used. We can see an expression that applies the short circuit logic in a compound AND operation in the following:<\/p>\n

c =<\/span> (<\/span> 0<\/span> |<\/span> 1<\/span> )<\/span> &&<\/span> (<\/span> 1<\/span> &<\/span> 1<\/span> )<\/span><\/div><\/div>\n

<\/a>
\nConclusion<\/h2>\n

In this Linux Ways article, we showed you how to use the operators available in C to perform the bitwise operations. In this article, we learned a table with the different operators available and then a section for each of them describing their function, the expression used, and how to use them with practical examples. We also provided you the tips that you need to handle the binary numbers and see their values on the screen so you can quickly understand the bitwise operations.\n<\/p><\/div>","protected":false},"excerpt":{"rendered":"

Comprehensive tutorial on how to use the available operators in C to perform the bitwise operations, their function, the expression used, and how to use them.<\/p>","protected":false},"author":110,"featured_media":23297,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[168],"tags":[],"class_list":["post-23240","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting"],"_links":{"self":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts\/23240","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/users\/110"}],"replies":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/comments?post=23240"}],"version-history":[{"count":0,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts\/23240\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/media\/23297"}],"wp:attachment":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/media?parent=23240"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/categories?post=23240"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/tags?post=23240"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}