<< Chapter < Page | Chapter >> Page > |
counter = counter + 1;
can be reduced to
counter += 1;
Here is the full set.
= | |
*= | Multyply |
/= | Divide |
%= | Modulus |
+= | Add |
-= | Subtract |
<<= | Left Shift |
>>= | Right Shift |
&= | Bitwise AND |
^= | Bitwise Exclusive OR (XOR) |
|= | Bitwise Ixclusive OR |
if expr1 and expr2 are expressions then
expr1 op= expr2 is equivalent to expr1 = expr1 op expr2
Relational operators
Operators | Meaning | Examples |
> | greater than |
2>3 (is 0)
6>4 (is 1)
a>b |
>= | greater than or equal to |
6>= 4 (is 1)
x>= a |
< | less than |
5<3 (is 0), |
<= | less than or equal to |
5<= 5 (is 1)
2<= 9 (is 1) |
== | equal to |
3 == 4 (is 0)
a == b |
!= | not equal to |
5 != 6 (is 1)
6 != 6 (is 0) |
Logical operators
Operators | Meaning | Data types of the operands | Examples |
&& | logical and | 2 logic expressions |
3<5&&4<6 (is 1)
2<1&&2<3 (is 0)
a>b&&c<d |
|| | logical or | 2 logic expressions |
6 || 0 (is 1)
3<2 || 3<3 (is 1)
x>= a || x == 0 |
! | logical not | 1 logic expression |
!3 (is 0)
!(2>5) (is 1) |
Operators | Meaning | Data types of the operands | Examples |
& | Binary AND | 2 binary numbers |
0&0 (is 0)
0&1 (is 0)
1&0 (is 0)
1&1 (is 1)
101&110 (is 100) |
| | Binary OR | 2 binary numbers |
0 | 0 (is 0)
0 | 1 (is 0)1 | 0 (is 0)
1 | 1 (is 1)101 | 110 (is 111) |
^ | Binary XOR | 2 binary numbers |
0 ^ 0 (is 0)
0 ^1 (is 1)1 ^ 0 (is 1)
1 ^ 1 (is 0)101 ^ 110 (is 011) |
<< | Shift left | 1 binary number |
a<<n (is a*2n)
101<<2 (is 10100) |
>> | Shift right | 1 binary number |
a>>n (is a/2n)
101>>2 (is 1) |
~ | One's complement | 1 binary number |
~ 0 (is 1)
~ 1 (is 0)~ 110 (is 001) |
Incrementing, decrementing and doing calculations on a variable is a very common programming task and C has quicker ways of writing the code. The code is rather cyptic in appearance.
The increment operator ++ adds 1 to its operand while the decrement operator - -subtract 1. We have frequently used ++ to increment variables, as in
if (c = = ’\n’)
++n;
The unusual aspect is that ++ and - - may be used either as prefix operators (before the variable, as in ++n) or postfix operators (after the variable, as in n++). In both cases, the effect is to increment n. But the expression ++n increments n before its value is used, while n++ increment n after its value has been used. This mean that in a context where the value is being used, not just the effect, ++n and n++ are different. For example, if n is 5, then
x = n++;
sets x to 5 but
x = ++n;
sets x to 6. In both cases, n becomes 6.
The five operators listed in the following table are used in addressing array elements and members of structures, and in using pointers to access objects and functions.
Operator | Meaning | Example | Result |
& | Address of | &x | Pointer to x |
* | Indirection operator | *p | The object or function that p points to |
[ ] | Subscripting | x[y] | The element with the index y in the array x (or the element with the index x in the array y: the [ ] operator works either way) |
. | Structure or union member designator | x.y | The member named y in the structure or union x |
-> | Structure or union member designator by reference | p->y | The member named y in the structure or union that p points to |
When an operator has operands of different types, they are converted to a common type according to a small number of rules. In general, the only automatic conversion era those that convert a narrower operand into a wider one without loosing information, such as converting an integer into floating point .
If there are no unsigned operands, the following informal set of rules will suffice:
If either operand is long double, convert the other to long double.
Otherwise, if either operand is double, convert the other to double.
Otherwise if either operand is float, convert the other to float.
Otherwise convert char and short to int.
Then if either operand is long, convert the other to long.
A char is just a small integer, so chars may be freely used in arithmetic expressions
Operators listed by type.
All operators on the same line have the same precedence. The first line has the highest precedence.
Level | Operators | Associativity |
1 | () [] . ->++ (postfix) – (postfix) | -----> |
2 | ! ~ ++ (prefix) -- (prefix) - *&sizeof | <----- |
3 | * / % | -----> |
4 | + - | -----> |
5 | <<>> | -----> |
6 | <<=>>= | -----> |
7 | == != | -----> |
8 | & | -----> |
9 | ^ | -----> |
10 | | | -----> |
11 | && | -----> |
12 | || | -----> |
13 | ?: | <----- |
14 | = += -= | <----- |
Note:associate left to right
Notification Switch
Would you like to follow the 'Introduction to computer science' conversation and receive update notifications?