<< 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

Logical and relational operators

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)

Bitwise operators

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)

Increment and decrement operators

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 increment and decrement operator can only be applied to variables; an expression like (i + j)++ is illegal.

Memory addressing operators

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

Type conversions

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

Precedence of operators

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

Get Jobilize Job Search Mobile App in your pocket Now!

Get it on Google Play Download on the App Store Now




Source:  OpenStax, Introduction to computer science. OpenStax CNX. Jul 29, 2009 Download for free at http://cnx.org/content/col10776/1.1
Google Play and the Google Play logo are trademarks of Google Inc.

Notification Switch

Would you like to follow the 'Introduction to computer science' conversation and receive update notifications?

Ask