C Language Zemi

Bitwise operator

This section describes bit operators in C language. Bitwise operations are operations performed in 1-bit units.

Bit AND operator

The bit AND operator "&" sets 1 at the corresponding position of the value to be returned if both of the bits contained in the two operands are 1, and 0 if either of the bits is 0. Set.

#Bit AND
x & y

Let's assume that both x and y are 8-bit unsigned integer type. z is the resulting value of the bit AND operator. If both the bits at the x and y positions are 1, the corresponding z bits are also 1, otherwise they are 0.

x 01001100
y 01000101

z 01000100

A sample bit AND operator.

#include <stdio.h>
#include <stdint.h>

int main (void) {
  // 01001100
  uint8_t x = 0x4C;
  
  // 01000101
  uint8_t y = 0x45;
  
  // 01000100
  uint8_t z = x & y;
  
  printf("%X\n", z);
}

This is the output result. The output is in hexadecimal, but if it is binary, it is "01000100".

44

Bit OR operator

The bit OR operator "|" is set to 1 at the corresponding position of the value to be returned when either of the bits contained in the two operands is 1 (both may be 1), and both of the bits are set. If is 0, set it to 0.

# Bit OR
x | y

Let's assume that both x and y are 8-bit unsigned integer type. z is the resulting value of the bit OR operator. If either the bit at the position of x or y is 1, the corresponding bit of z is also 1, and if both are 0, it is 0.

x 01001100
y 01000101

z 01001101

This is a sample of the bit OR operator.

#include <stdio.h>
#include <stdint.h>

int main (void) {
  // 01001100
  uint8_t x = 0x4C;
  
  // 01000101
  uint8_t y = 0x45;
  
  // 01001101
  uint8_t z = x | y;
  
  printf("%X\n", z);
}

This is the output result. The output is in hexadecimal, but if it is binary, it is "01001101".

4D

Bit XOR operator

The bit XOR operator "^" is set to 1 at the corresponding position of the value to be returned if only one of the bits contained in the two operands is 1, and both of the bits are 0 or 1. If so, set it to 0.

#Bit XOR
x ^ y

Let's assume that both x and y are 8-bit unsigned integer type. z is the resulting value of the bit XOR operator. If only one bit at one of the x and y positions is 1, the corresponding z bit is also 1, and if both are 0 or 1, it is 0.

x 01001100
y 01000101

z 00001001

A sample bit XOR operator.

#include <stdio.h>
#include <stdint.h>

int main (void) {
  // 01001100
  uint8_t x = 0x4C;
  
  // 01000101
  uint8_t y = 0x45;
  
  // 0001001
  uint8_t z = x ^ y;
  
  printf("%X\n", z);
}

This is the output result. The output is in hexadecimal, but if it is binary, it is "0001001".

9

Bit NOT operator

The bit NOT operator "~" inverts a bit contained in the operand.

# Bit NOT
~ x

Let's assume that both x and y are 8-bit unsigned integer type. z is the result value of the bit NOT operator. The x bit is inverted.

x 01001100

z 10110011

This is a sample of the bit NOT operator. The output result is bit ANDed with "0xFF" to eliminate the effect of integer type extension. ..

#include <stdio.h>
#include <stdint.h>

int main (void) {
  // 01001100
  uint8_t x = 0x4C;
  
  // 01000101
  uint8_t y = 0x45;
  
  // 10110011
  uint8_t z = ~ x;
  
  printf("%X\n", z);
}

This is the output result. The output is in hexadecimal, but if it is binary, it is "01000100".

B3

Special operator that combines bit operator and "="

There are special operators that combine bitwise operators with "=".

# Same meaning as "x = x & y"
x & = y

# Same meaning as "x = x | y"
x | = y

# Same meaning as "x = x ^ y"
x ^ = y

When do you use bitwise operators in practice?

The most common use of bitwise operators is when passing flags to function arguments. In C language, flags are often passed as integers, but in that case, the meaning is determined by the position of the bit. Use enum enum to define a flag for each bit. 1 (1 in binary), 2 (10 in binary), 4 (100 in binary), 8 (1000 in binary).

Bit OR "| =" to set each bit, and bit XOR "^ =" to drop each bit.

Use "&" to check if a bit is set.

Sample code to create a flag to pass to a function argument.

#include <stdio.h>
#include <stdint.h>

enum {
  MYAPP_FLAG1 = 1,
  MYAPP_FLAG2 = 2,
  MYAPP_FLAG3 = 4,
  MYAPP_FLAG4 = 8,
  MYAPP_FLAG5 = 16,
  MYAPP_FLAG6 = 32,
  MYAPP_FLAG7 = 64,
  MYAPP_FLAG8 = 128,
  MYAPP_FLAG9 = 256,
  MYAPP_FLAG10 = 512,
};;

int main (void) {
  uint32_t flag = 0;
  
  // Build MYAPP_FLAG4
  flag | = MYAPP_FLAG4;
  
  // 00000000 00000000 00000000 00001000
  printf("%X\n", flag);
  
  // Build MYAPP_FLAG10
  flag | = MYAPP_FLAG10;

  // 00000000 00000000 00000010 00001000
  printf("%X\n", flag);
  
  // Drop MyAPP_FLAG4
  flag ^ = MYAPP_FLAG4;
  
  // 00000000 00000000 00000010 00000000
  printf("%X\n", flag);
  
  // Check if the bit is set
  if (flag & MYAPP_FLAG10) {
    printf("MYAPP_FLAG10 ok\n");
  }
}