Would you know, categorically, what the variable `x`

will contain?

`x = 3 * 2 < 4;`

The question raised here is which operator will be executed first: multiplication or comparison? There is a table of operator precedence shown below. You can see that multiplication (precedence 3) has priority over comparison (prcedence 6):

Precedence | Operators | Description | Associativity |
---|---|---|---|

1 | `++` `--` |
Pre-increment and pre-decrement | |

2 | `!` `~` `+` `-` |
Unary operators | |

3 | `*` `/` `%` |
Multiplication, division and modulo | |

4 | `+` `-` |
Addition and subtraction | |

5 | `<<` `>>` |
Bit shifting | |

6 | `<` `>` `<=` `>=` |
Comparison operators | |

7 | `==` `!=` |
Equality operators | |

8 | `&` |
Logical bitwise AND | |

9 | `^` |
Exclusive bitwise OR | |

10 | `|` |
Inclusive bitwise OR | |

11 | `&&` |
Logical ANBD | |

12 | `||` |
Logical OR | |

13 | `=` `!=` `+=` `*=` `&=` etc |
Assignment operators | |

14 | `++` `--` |
Post-increment and post-decrement |

Would you be able, now, to give with certainty the value of `x`

after these lines of code?

```
int a=5, x;
x = a = 3;
```

In this example, the `=`

operator appears twice in the same instruction. Of course,
both operators have the same precedence. But fortunately, for each operator is defined
an associativity. It is this associativity that determines the order of operators of the same precedence.
In the last column of the precedence table we see that the associativity
is defined from the right to the left for the `=`

operator. The equivalent instructions are therefore :

```
int a=5, x;
a = 3;
x = a;
```

Obviously, no one knows the priority table by heart. The easiest way, if you are doubt, is to add parentheses to impose the order of execution of the of the different operators. This also makes it easier for other developers to u nderstand your code if they have to analyze it. Just remember that the multiplication and division operators have priority over over addition and subtraction.

Write a program that calculates the value of x (eliminate unnecessary brackets):

$$ x = \dfrac{125,5+12,5}{5468,12} - 12,5*2,54 $$

The result of the calculation should be -31.724763.

**Will a precedence 1 operator be executed after a precedence 2 operator?**

Check
Bravo! High precedence (low number) operators are executed first.
Try again...

**When does associativity apply?**

Check
Bravo! As soon as there are two operators with the same precedence, associativity comes into play.
Try again...

**How to write this instruction to make it easier to understand.**

`x = c > a * b;`

Check
Bravo! Multiplication takes precedence over comparison.
Try again...

**How to write this instruction to make it easier to understand.**

`x = 3 * 2 && 0;`

Check
Bravo! Here,

`x`

will always be equal to 0 because the last operation is always `&& 0`

.
Try again...
**What will be the value of the variable x after these lines?**

```
int a=3, x;
x = a += 5;
```

Check
Bravo! Operator

`+=`

is executed first because associativity is from right to left.
Try again...
**What will be the value of the variable x after these lines?**

```
int a=3, x;
x = a == 5;
```

Check
Bravo! Operator

`==`

is executed first and comparison will always return 0.
Try again...
**What will be the value of the variable x after these lines?**

```
int a=-3;
x = 0<a<20;
```

Check
Bravo! Comparisons will be performed from left to right: (0<-3)<20). This is not the right way to test an interval.
Try again...

**What will be the value of the variable x after these lines?**

```
int a=-3;
x = 0<a && a<20;
```

Check
Bravo! The comparisons will be executed before the logical operator. This is the right way to test an interval.
Try again...

- Learn C programming
- Lesson 1.1. History of C programming language
- Lesson 1.2. First program
- Lesson 1.3. Compilation
- Lesson 1.4. Preprocessor directives
- Lesson 1.5. Which compiler to choose?
- Lesson 1.6. Flowchart
- Lesson 2.1. Types and variables
- Lesson 2.2. Integers
- Lesson 2.3. Floating point numbers
- Lesson 2.4. Characters
- Lesson 2.5. Variables initialization
- Lesson 2.6. Ariane flight 501
- Lesson 3.1. Arithmetic operators
- Lesson 3.2. modulo
- Lesson 3.3. Operators and types
- Lesson 3.4. Type casting
- Lesson 3.5. Bitwise operators
- Lesson 3.6. Bitwise operators details
- Lesson 3.7. Shifting operators
- Lesson 3.8. Assignment operators
- Lesson 3.9. Increment and decrement operators
- Lesson 3.10. Comparison operators
- Lesson 3.11. Logical operators
- Lesson 4.1. printf
- Lesson 4.2. scanf
- Lesson 4.3. putchar
- Lesson 5.1. Conditional branching (if...else)
- Lesson 5.2. Nested if and indentation
- Lesson 5.3. Checking intervals
- Lesson 5.4. Ternary Operator ?:
- Lesson 5.5. switch..case statement
- Lesson 5.6. Break keyword in switch..case
- Lesson 6.1. do..while loop in C
- Lesson 6.2. While loop in C
- Lesson 6.3. For loop in C
- Lesson 6.4. How to choose the right loop in C ?
- Lesson 6.5. Exercices on loops in C
- Lesson 7.1. Bit masking
- Lesson 7.2. Bit masking, how to clear a bit in C?
- Lesson 7.3. Bit masking, how to set a bit in C?
- Lesson 7.4. Bit masking, how to toggle a bit in C?
- Lesson 7.5. Bit masking, how to check a single bit in C?
- Lesson 7.6. Overview of bit masking
- Lesson 8.1. Basic syntax of C functions
- Lesson 8.2. Calling C functions
- Lesson 8.3. Void keyword
- Lesson 8.4. Return keyword
- Lesson 8.5. Variable scope
- Lesson 8.6. Global variables
- Lesson 8.7. Static variables
- Lesson 8.8. Random numbers in C
- Lesson 8.9. Mathematical functions in C
- Lesson 9.1. Syntax of C arrays
- Lesson 9.2. Array initialization
- Lesson 9.3. Multidimensional arrays
- Lesson 9.4. How C arrays are stored in memory?
- Lesson 9.5. Arrays and functions
- Lesson 9.6. Exercises on C arrays
- Lesson 10.1. Strings in C
- Lesson 10.2. Null terminated string
- Lesson 10.3. The string.h library
- Lesson 10.4. String and functions
- Lesson 11.1. Introduction to pointers in C
- Lesson 11.2. Syntax of C pointers
- Lesson 11.3. Dynamic memory allocation
- Lesson 11.4. Incrementing pointers
- Lesson 11.5. Pointers as function argument in C
- Lesson 12.1. Introduction to structures in C
- Lesson 12.2. Properties of structures in C
- Lesson 12.3. Structures and pointers
- Lesson 12.4. Structures and functions
- Lesson 13.1. Recursive functions in C
- Lesson 13.2. Depth of recursive functions
- Lesson 13.2. Mutual recursion
- Lesson 14.1. Additional exercises

Last update : 11/21/2022