# Shift operators

## Shift right

The right shift is divided into:

Arithmetic shift: discard the right and fill the original symbol bit on the left

Shift left: 0, fill right: 0

### Positive shift method

A binary number contains the inverse complement of the original code

When shifting, the complement is moved

Positive number

For example:

int a=16；

Original code, inverse code and complement code are

00000000000000000000000000010000

If a is shifted one bit to the right

int b = a>>1;

The right side of the complement is discarded and the sign bit is added to the left.

The complement becomes: 000000000000000000000000000

Because the original and inverse complement of positive numbers are the same, they are converted to decimal.

a becomes 8.

### Negative shift method

For example:

int a=-1； int b=a>>1；

The binary source code whose first bit is sign bit a is

10000000000000000000000000000001

Inverse code: the sign bit remains unchanged, and other bits are reversed

111111111111111111111111111111111110

Complement: inverse code + 1

111111111111111111111111111111111111

After moving right

Lost the 1 on the right and added a 1 on the left. There is no change

So after moving right, b is still - 1.

## Shift left

There is only one way

Discard on the left and fill 0 on the right

# Bitwise operators

Bitwise operators are:

&Bitwise AND;

|Bitwise OR;

^Bitwise XOR;

## Bitwise AND

int c = a&b；

Compare the complement. If the complement binary of a is the same as that of b, the binary bit of c is 1;

For example, complement a: 00000000000000000101

Complement b: 0000000000000000000000

Complement c: 0000000000000000000000

## Bitwise OR

int c = a|b；

Compare the complement. If the complement binary of a is the same as that of b, one bit is 1, then the binary bit of c is 1;

For example, complement a: 0000000000000111

Complement b: 0000000000000000000000

Complement c: 000000000000000000111

## Bitwise XOR

int c = a^b;

Compare the complement. In the complement of c, if the complement binary of a is the same as that of b, the bit is 0 and the different bit is 1;

For example, complement a: 0000000000000111

Complement b: 0000000000000000000000

Complement c: 000000000000000000000000000000 11

## Practical interview questions

Exchange the values of integer a and integer b without establishing temporary variables

### Writing 1: simple writing

int main() { int a = 3; int b = 5; a = a + b; b = a - b; a = a - b; printf("a = %d\nb = %d ", a, b); return 0; }

### Notation 2: XOR notation

Use the value of a ^ b as the password.

int main() { int a = 3; int b = 5; a = a ^ b; b = a ^ b; a = a ^ b; printf("a = %d\nb = %d ", a, b); return 0; }

HKCEE, but not practical.

## Exercise: find the number of 1 in the binary number of an integer stored in memory

### The first way to write: negative numbers are not available

#include<stdio.h> int main() { int a = 0; scanf("%d", &a); int count = 0; while (a) { if (a % 2 == 1) count++; a = a / 2; } printf("%d", count); return 0; }

# Assignment operator

## Compound assignor

int a = 0; a+=1 == a=a+1; a&=1 a*=2 a*=2 a%=2

Like this

# unary operator

There is only one operand

## ! Operator

True becomes false, false becomes true

int a = 0； a=!a; a==1;

int a = 10; a=!a; a==0;

Application scenario

int a = 0; if(!a)//If a is false, print hehe { printf("hehe\n"); }

## Fetch address operator&

int a = 10; int* p = &a;//Store the address of a with a pointer *P ; //Dereference operation, the result is the value of a

## Type length of operand sizeof

int main() { char c = '0'; int arr[10] = { 0 }; int a = 0; char* p = &c; printf("%d", sizeof(a));//4 printf("%d", sizeof(int)); printf("%d", sizeof(c));//1 printf("%d", sizeof(char)); printf("%d", sizeof(p));//4 printf("%d", sizeof(char*)); printf("%d", sizeof(arr));//40 printf("%d", sizeof(int[10])); //For arrays, removing the name leaves the type }

For arrays, the only thing left after removing the name is the type

### Classic questions

int main() { short s = 0; int a = 0; printf("%d\n", sizeof(s = a + 5)); printf("%d\n", s); }

Guests are welcome. sizeof is short integer

The value of s has not changed.

So it's printed out as 2 and 0