Bitwise NOT

The bitwise NOT operation, also known as bitwise complement or bitwise negation, is a unary operation that operates on individual bits of a single operand. It is denoted by the tilde (~) symbol. The bitwise NOT operation flips the bits of the operand, changing 0 to 1 and 1 to 0.

Here's an explanation of how the bitwise NOT operation works:

The operation flips the value of each bit in the operand, resulting in the complement of the original bit.

Let's consider an example to illustrate the bitwise NOT operation:


Operand: 10101010

Result: 01010101
Explanation:
- Flipping the value of each bit:
  - 1 becomes 0
  - 0 becomes 1

Therefore, the bitwise NOT operation produces the result 01010101.

In programming languages, the bitwise NOT operation is often used to invert or complement the bits of an integer value. It can be used to perform various operations such as toggling specific bits, inverting flags, or implementing bit-level manipulations.

It's important to note that the bitwise NOT operation is a unary operation, meaning it operates on a single operand. The operation flips the value of each bit in the operand independently, without considering the values of other bits.

In C++, the bitwise NOT operator (~) is used to perform a bitwise NOT operation on an operand, which inverts each bit of the operand.


#include <iostream>
using namespace std;

int main() {

    int a = 10;   // Binary representation: 1010

    // Bitwise NOT operation using the ~ operator
    int b = ~a;   // Binary representation: 0101
    cout << "~a = " << b << endl;  // Output: ~a = -11

    a = 20;   // Binary representation: 10100

    b = ~a;   // Binary representation: 01011
    cout << "~a = " << b << endl;  // Output: ~a = -21

    return 0;
}

In this code, the integer variable a is initialized with decimal value 10. The bitwise NOT operator ~ is used to perform the bitwise NOT operation on a, which inverts each bit of a to resulting in a binary representation of 0101. The resulting integer value is stored in the integer variable b and outputted to the console using cout.

The binary representation of a is also shown in the comments of the code. To perform the bitwise NOT operation, each bit of a is flipped, with 0 becoming 1 and 1 becoming 0. The resulting integer value is the decimal value of the inverted binary representation.

The second section of the code demonstrates the use of the bitwise NOT operator on a different decimal value of a.

It is worth noting that the bitwise NOT operation on signed integers can result in unexpected behavior due to the representation of negative numbers in binary. In the code above, the result of the bitwise NOT operation on 10 results in -11 being printed to the console, which may not be the expected result. This is because of the "Two's Complement" representation of negative numbers in binary, which leads to the resulting negative value.