# Fundamentals of C language - learning notes - detailed explanation of operators

Keywords: C

## Operators and expressions

Key points of this chapter
1. Introduction to various operators.
2. Evaluation of expression.

## Operator

Classification:

• Arithmetic operator
• Shift operators
• Bitwise operators
• Assignment operator
• unary operator
• Relational operator
• Logical operator
• Conditional Operator
• comma operator
• Subscript references, function calls, and structure members

### Arithmetic operator

```+ - * / %
```

1. In addition to the% operator, several other operators can act on integers or floating-point numbers.
2. For the / operator, if both operands are integers, perform integer division. Floating point division is performed if only one end has a floating point number.
The two operands of the 3.% operator must be integers and return the remainder after integer division.

### Shift operators

```<< Shift left operator
>> Shift right operator
```
```int main() {
int a = 2;
//Move the binary bit of a one bit to the left
int b = a << 1;
//Move the binary bit of a one bit to the right
int c = a >> 1;

printf("b = %d\n",b);
printf("c = %d\n",c);
return 0;
}
```

Warning: shift cannot move negative digits; ### Bitwise operators

```&  Bitwise AND
|  Bitwise OR
^  Bitwise XOR
Note: their operands must be integers
```
```int main() {
//3 - 00000000000000000000000000000011
//5 - 00000000000000000000000000000101
int a = 3;
int b = 5;
//&- by (binary) bits and
int c = a & b;
// |- Press (binary) or
int d = a | b;
// ^- exclusive or by (binary) bit
// XOR the corresponding binary bit
// Rule: the same is 0 and the difference is 1
int e = a ^ b;
printf("c = %d\n",c);
printf("d = %d\n",d);
printf("e = %d\n",e);
return 0;
}
```

Exercise: write code to realize: find the number of 1 in the binary of an integer stored in memory.

### Assignment operator

```int weight = 100;
weight = 89;
```

### Compound operator

```+=
-=
*=
/=
%=
&=
|=
^=
>>=
<<=
```
```int a = 10;
a = a + 10;
a += 10;//Compound Assignment
```

### unary operator

Unary operator - only one operand

```!      Logical reverse operation
-       negative
+       positive
sizeof  The type length of the operand in bytes
~       Bitwise negation of a number
--      Front and rear--
++      Front and rear++
*       Indirect access operator (dereference operator)
(type)  Cast type
```

sizeof is an operator, not a function

```int main() {

short s = 5;
int a = 10;
//The expression in sizeof parentheses does not participate in the operation!
printf("%d\n",sizeof(s = a + 2));
printf("%d\n",s);

int a = 10;
int arr = {0};
printf("%d\n",sizeof(arr));//The unit is byte
printf("%d\n",sizeof(int ));//40 - int  is the type of arr array
return 0;
}
```
```int main() {
int a = 4;
//00000000000000000000000000000100 - 4

//01111111111111111111111111111011
//00000000000000000000000000000100
//00000000000000000000000000000101 - 5
a = ~a;
printf("%d\n",a);
return 0;
}
```

```int main() {
int a = 10;
int* pa = &a;//pa is used to store addresses - pa is a pointer variable
*pa = 20;	//Dereference operator - Introduction to access operators
printf("%d\n",a);//20
return 0;
}
```

### Relational operator

```>
>=
<
<=
!=  //Used to test "inequality"
==  //be used for
```

### Logical operator

```&&   Logic and
||   Logical or
```

#### Distinguishing logic and bitwise and distinguishing logic or and bitwise OR

```1&2    ---> 0
1&&2   ---> 1

1|2    ---> 3
1||2   ---> 1
```

#### Characteristics of logic and or:

If a=0 in a & & b, b does not participate in the operation.
If a=1 in a | b, b does not participate in the operation.

```int main() {
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf("a = %d\nb = %d\nc = %d\nd = %d\n",a,b,c,d);
return 0;
}
```

### Ternary operator (conditional operator)

```exp1 ? exp2 : exp3
```

practice:

```int main() {
int a = 0;
int b = (a > 5 ? 1 : -1);

printf("%d\n",b);
return 0;
}
```

### comma expression

Comma expressions are multiple expressions separated by commas. You want to evaluate from left to right, but the result of the entire expression is the result of the last expression.

```int main() {
int a = 5;
int b = 3;
int c = 0;
//Comma expression - evaluates from left to right, but the result of the entire expression is the result of the last expression
int d = (c = 1, a = c + 3,b = a - 4,c += 5);
printf("d = %d\n",d);
return 0;
}
```
```//
a = get_val();
count_val(a);
while(a>0){
a = get_val();
count_val(a);
}

//If you use a comma expression, override:
while(a =  get_val(),count_val(a),a>0){

}
```

### 1. [] subscript reference operator

Operand: an array name + an index value

```int main() {
int arr = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n",arr);// [] - is the subscript reference operator
// The operands of [] are 2: arr, 4

return 0;
}
```

### 2. () function call operator

Receive one or more operands: the first operand is the function name, and the remaining operands are the parameters passed to the function.

### 3. Visit members of a structure

. structure. Member name
->Structure pointer - > member name

```//Create a structure
struct Book {
//Member of structure (variable)
char name;
char id;
int price;
};

int main() {
struct Book b = {"C language","C20102",55};
struct Book* pb = &b;

//Structure variable name. Member name
printf("title:%s\n",b.name);
printf("Book No.:%s\n",b.id);
printf("Price:%d\n",b.price);
//Structure pointer - > member name
printf("title:%s\n", pb->name);
printf("Book No.:%s\n", pb->id);
printf("Price:%d\n", pb->price);

return 0;
}
```

## Expression evaluation

### Implicit type conversion

The shaping arithmetic operation of C is always performed at least with the precision of the default integer type.
To achieve this precision, the characters and short operands in the expression are converted to normal integers before use, which is called integer promotion. How to improve integer?

Integer promotion is carried out according to the sign bit of the data type of the variable  Examples of integer lifting:

```int main() {
char a = 3;
//00000000000000000000000000000011
//00000011 - a
char b = 127;
//00000000000000000000000001111111
//01111111 - b
char c = a + b;
//00000000000000000000000000000011
//00000000000000000000000001111111
//00000000000000000000000010000010

//100000010 - c
//11111111111111111111111111100000010 - complement
//11111111111111111111111100000001 - inverse code
//100000000000001111110 - original code
//111111110
//It is found that both a and b are char types, and neither of them reaches the size of an int
//There will be plastic lifting
printf("%d\n",c);  // -126
return 0;
}
```

### Arithmetic conversion

Properties of the operator
There are three factors that affect the evaluation of complex expressions.

1. operator precedence
2. Tuberculousness of operators
3. Control evaluation order

Posted by gregtel on Sun, 05 Sep 2021 15:40:31 -0700