C++ Programming Code Examples
C++ > Beginners Lab Assignments Code Examples
Bitwise operators are similar to the logic operators, but they perform the same logical operations on bits.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
Bitwise operators are similar to the logic operators, but they perform the same logical operations on bits.
All data in memory is represented in the binary form. So, variables in form of bits contains only 0 or 1. The following table represents the result of operations for the bitwise operators:
X Y X & Y X  Y X ^ Y
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1
Binary AND operator "&"
The resultant bit is set to 1 if and only if both variables have 1 in the corresponding bit. Example of binary &:
10100110 & 00101010 = 00100010
Binary OR operator ""
The resultant bit is set to 1 if at least one of the variables has 1 in the corresponding bit. Example of binary :
10100110  00101010 = 10101110
Binary XOR operator "^"
The result bit is set to 1 if only one of the variables has 1 in the corresponding bit. Example of Binary xor:
10100110 ^ 00101010 = 10001100
Binary NOT operator "~"
Flips the bits of the variable. For Example:
~10100110 = 01011001
Binary Left Shift Operator "<< N"
Will shift 'N' number of bits to the left. In simple words, N number of bits from the Left will be removed and N number of Zeros will be added to the Right. For Example:
10100110 << 3 = 00110000
Binary Right Shift Operator ">> N"
Will shift 'N' number of bits to the right. In simple words, N number of bits from the Right will be removed and N number of Zeros will be added to the Left. For Example:
10100110 >> 2 = 00101001
Assignment Operators in C++
As the name already suggests, these operators help in assigning values to variables. These operators help us in allocating a particular value to the operands. The main simple assignment operator is '='. We have to be sure that both the left and right sides of the operator must have the same data type. We have different levels of operators.
Assignment operators are used to assign the value, variable and function to another variable. Assignment operators in C are some of the C Programming Operator, which are useful to assign the values to the declared variables. Let's discuss the various types of the assignment operators such as =, +=, =, /=, *= and %=. The following table lists the assignment operators supported by the C language:
=
Simple assignment operator. Assigns values from right side operands to left side operand
+=
Add AND assignment operator. It adds the right operand to the left operand and assign the result to the left operand.
=
Subtract AND assignment operator. It subtracts the right operand from the left operand and assigns the result to the left operand.
*=
Multiply AND assignment operator. It multiplies the right operand with the left operand and assigns the result to the left operand.
/=
Divide AND assignment operator. It divides the left operand with the right operand and assigns the result to the left operand.
%=
Modulus AND assignment operator. It takes modulus using two operands and assigns the result to the left operand.
<<=
Left shift AND assignment operator.
>>=
Right shift AND assignment operator.
&=
Bitwise AND assignment operator.
^=
Bitwise exclusive OR and assignment operator.
=
Bitwise inclusive OR and assignment operator.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/* Assignment operators are used to assigning value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same datatype of the variable on the left side otherwise the compiler will raise an error. */
// C++ program to demonstrate working of Assignment operators
#include <iostream>
using namespace std;
int main()
{
// Assigning value 10 to a
// using "=" operator
int a = 10;
cout << "Value of a is "<<a<<"\n";
// Assigning value by adding 10 to a
// using "+=" operator
a += 10;
cout << "Value of a is "<<a<<"\n";
// Assigning value by subtracting 10 from a
// using "=" operator
a = 10;
cout << "Value of a is "<<a<<"\n";
// Assigning value by multiplying 10 to a
// using "*=" operator
a *= 10;
cout << "Value of a is "<<a<<"\n";
// Assigning value by dividing 10 from a
// using "/=" operator
a /= 10;
cout << "Value of a is "<<a<<"\n";
return 0;
}
Bitwise Operators in C++
The bitwise operators are the operators used to perform the operations on the data at the bitlevel. When we perform the bitwise operations, then it is also known as bitlevel programming. It consists of two digits, either 0 or 1. It is mainly used in numerical computations to make the calculations faster. We have different types of bitwise operators in the C++ programming language. The following is the list of the bitwise operators:
&
Bitwise AND operator is denoted by the single ampersand sign (&). Two integer operands are written on both sides of the (&) operator. If the corresponding bits of both the operands are 1, then the output of the bitwise AND operation is 1; otherwise, the output would be 0.
This is one of the most commonly used logical bitwise operators. It is represented by a single ampersand sign (&). Two integer expressions are written on each side of the (&) operator.
The result of the bitwise AND operation is 1 if both the bits have the value as 1; otherwise, the result is always 0.
The bitwise AND operator is a single ampersand: &. A handy mnemonic is that the small version of the boolean AND, &&, works on smaller pieces (bits instead of bytes, chars, integers, etc). In essence, a binary AND simply takes the logical AND of the bits in each position of a number in binary form.
01001000 & 10111000 = 00001000
The most significant bit of the first number is 0, so we know the most significant bit of the result must be 0; in the second most significant bit, the bit of second number is zero, so we have the same result. The only time where both bits are 1, which is the only time the result will be 1, is the fifth bit from the left.

Bitwise OR operator is represented by a single vertical sign (). Two integer operands are written on both sides of the () symbol. If the bit value of any of the operand is 1, then the output would be 1, otherwise 0.
It is represented by a single vertical bar sign (). Two integer expressions are written on each side of the () operator.
The result of the bitwise OR operation is 1 if at least one of the expression has the value as 1; otherwise, the result is always 0.
Bitwise OR works almost exactly the same way as bitwise AND. The only difference is that only one of the two bits needs to be a 1 for that position's bit in the result to be 1. (If both bits are a 1, the result will also have a 1 in that position.) The symbol is a pipe: . Again, this is similar to boolean logical operator, which is .
01001000  10111000 = 11111000
^
Bitwise exclusive OR operator is denoted by (^) symbol. Two operands are written on both sides of the exclusive OR operator. If the corresponding bit of any of the operand is 1 then the output would be 1, otherwise 0.
The bitwise XOR ^ operator returns 1 if and only if one of the operands is 1. However, if both the operands are 0, or if both are 1, then the result is 0.
The following truth table demonstrates the working of the bitwise XOR operator. Let a and b be two operands that can only take binary values i.e. 1 or 0.
There is no boolean operator counterpart to bitwise exclusiveor, but there is a simple explanation. The exclusiveor operation takes two inputs and returns a 1 if either one or the other of the inputs is a 1, but not if both are. That is, if both inputs are 1 or both inputs are 0, it returns 0. Bitwise exclusiveor, with the operator of a caret, ^, performs the exclusiveor operation on each pair of bits. Exclusiveor is commonly abbreviated XOR.
01110010 ^ 10101010 = 11011000
~
Bitwise complement operator is also known as one's complement operator (unary operator). It is represented by the symbol tilde (~). It takes only one operand or variable and performs complement operation on an operand. When we apply the complement operation on any bits, then 0 becomes 1 and 1 becomes 0.
The bitwise complement operator, the tilde, ~, flips every bit. A useful way to remember this is that the tilde is sometimes called a twiddle, and the bitwise complement twiddles every bit: if you have a 1, it's a 0, and if you have a 0, it's a 1.
The bitwise complement is also called as one's complement operator since it always takes only one value or an operand. It is a unary operator.
When we perform complement on any bits, all the 1's become 0's and vice versa.
If we have an integer expression that contains 0000 1111 then after performing bitwise complement operation the value will become 1111 0000.
Bitwise complement operator is denoted by symbol tilde (~).
The bitwise shift operators are used to move/shift the bit patterns either to the left or right side. Left and right are two shift operators provided by 'C' which are represented as follows:
Operand << n (Left Shift),
Operand >> n (Right Shift)
an operand is an integer expression on which we have to perform the shift operation.
'n' is the total number of bit positions that we have to shift in the integer expression.
<<
Leftshift operator  It is an operator that shifts the number of bits to the leftside. Left shift operator shifts all bits towards left by a certain number of specified bits. The bit positions that have been vacated by the left shift operator are filled with 0. The symbol of the left shift operator is <<.
The left shift operation will shift the 'n' number of bits to the left side. The leftmost bits in the expression will be popped out, and n bits with the value 0 will be filled on the right side.
>>
Rightshift operator  It is an operator that shifts the number of bits to the right side. Right shift operator shifts all bits towards right by certain number of specified bits. It is denoted by >>.
The right shift operation will shift the 'n' number of bits to the right side. The rightmost 'n' bits in the expression will be popped out, and the value 0 will be filled on the left side.
X Y X&Y XY X^Y
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 1
Shifts operators can be combined then it can be used to extract the data from the integer expression.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/* bitwise operators in C++ language*/
#include <iostream>
using namespace std;
int main() {
// a = 5(00000101), b = 9(00001001)
int a = 5, b = 9;
// The result is 00000001
cout<<"a = " << a <<","<< " b = " << b <<endl;
cout << "a & b = " << (a & b) << endl;
// The result is 00001101
cout << "a  b = " << (a  b) << endl;
// The result is 00001100
cout << "a ^ b = " << (a ^ b) << endl;
// The result is 11111010
cout << "~(" << a << ") = " << (~a) << endl;
// The result is 00010010
cout<<"b << 1" <<" = "<< (b << 1) <<endl;
// The result is 00000100
cout<<"b >> 1 "<<"= " << (b >> 1 )<<endl;
return 0;
}
C++ sample ask to enter a number to reverse it, then check whether reverse is equal to its "original or not", if "it is equal" then it will be palindrome else it will be not be palindrome:
C++ Program to find edge connectivity of a graph. An edge in an undirected connected graph is a bridge if removing it disconnects the graph. For a "disconnected undirected"
Program display the minimum heap method of arranging elements. "Minimum Heap" is a method of "Arranging Elements" in a Binary search tree where value of the parent node is
A simple c++ program which shows using of switch statement in c++. C++ Program which takes input a grade and display Grade Points Average GPA. Program takes inputs A,a, B,b,