Operators

suggest change

Introduction

An operator in a programming language is a symbol that tells the compiler or interpreter to perform a specific mathematical, relational or logical operation and produce a final result.

C has many powerful operators. Many C operators are binary operators, which means they have two operands. For example, in a / b, / is a binary operator that accepts two operands (a, b). There are some unary operators which take one operand (for example: ~, ++), and only one ternary operator ? :.

Syntax

Remarks

Operators have an arity, a precedence and an associativity.

a * b + c

Gives the same result as

(a * b) + c

If this is not what was wanted, precedence can be forced using parentheses, because they have the highest precedence of all operators.

a * (b + c)

This new expression will produce a result that differs from the previous two expressions.

The C language has many precedence levels; A table is given below of all operators, in descending order of precedence.

**Precedence Table**

Operators                                                     | Associativity
------                                                        | ------
`()` `[]` `->` `.`                                            | left to right
`!` `~` `++` `--` `+` `-` `*` (dereference) `(type)` `sizeof` | right to left
`*` (multiplication) `/` `%`                                  | left to right
`+` `-`                                                       | left to right
`<<` `>>`                                                     | left to right
`<` `<=` `>` `>=`                                             | left to right
`==` `!=`                                                     | left to right
`&`                                                           | left to right
`^`                                                           | left to right
<code>&#124;</code>                                                          | left to right
`&&`                                                          | left to right
<code>&#124;&#124;</code>                                                        | left to right
`?:`                                                          | right to left
`=` `+=` `-=` `*=` `/=` `%=` `&=` `^=` <code>&#124;=</code> `<<=` `>>=`       | right to left
`,`                                                          | left to right
a - b - c - d

has three identical-precedence subtractions, but gives the same result as

((a - b) - c) - d

because the left-most \- binds first to its two operands.

An example of Right-to-Left associativity are the dereference \* and post-increment ++ operators. Both have equal precedence, so if they are used in an expression such as

* ptr ++

, this is equivalent to

* (ptr ++)

because the rightmost, unary operator (++) binds first to its single operand.

Feedback about page:

Feedback:
Optional: your email if you want me to get back to you:



Table Of Contents