Operators

Operator Return Values

• In C, every operator returns a value

Simple Assignment: =

• assignment operators return the value being assigned
• a = 1 sets a to 1 (and returns 1)
• b = 1.23 sets b to 1.23 (and returns 1.23)
• c = a sets c to whatever is in a (and returns the value of a)

Unary Plus and Minus: + and -

• a = -32 sets a to -32
• b = -1.4 sets b to -1.4
• c = +10 sets c to 10

Addition and Subtraction: + and -"

• a = 1 + 1 sets a to 2
• b = 3.5 + 2.1 sets b to 5.6
• c = a - 2 + 1 sets c to whatever is in a less 1, because the statement is evaluated from left to right. If a is set to 4, evaluation would proceed like:

  	a - 2 + 1
  	4 - 2 + 1
  	2 + 1
  	3
  

• Note that the result of an addition overflow (where the result is larger than the maximum value storeable in the variable) is undefined

Multiplication and Division: * and /

• a = 5 * 2 sets a to 10 (5 times 2)
• b = 7.0 / 4.0 sets b to 1.75
• c = 7 / 4 sets c to 1 (because integer divison always rounds down)
• Note that the result of division by 0 or multiplication overflow is undefined

Remainder: %

• a = 5 % 2 sets a to 1
• c = 7 % 4 sets c to 3
• Note that the result of remainder by 0 is undefined
• Note also that this only works for integral types (since it doesn't make sense for floating-point numbers, where there is no remainder)
• It is always true that (a/b)*b + a%b is equal to a
• It is always true that a%b is equal to a if 0 < a < b or 0 < -a < -b

Prefix Increment and Prefix Decrement: ++ and --

• ++a sets a to (a+1) and returns that value
• b = ++a sets both a and b to (a+1)

Postfix Increment and Postfix Decrement: ++ and --

• a++ sets a to (a+1) but returns the original value of a
• b = a++ sets b to a and a to (a+1)

Parentheses: ( and )

• parentheses are a way of grouping operators so that they are evaluated together
• since expressions are normally evaluated from left to right,
• 3 * 5 / 2 is the same as (3 * 5) / 2, which is evaluated as:
  • (3 * 5) / 2
  • 15 / 2
  • 7
• if the expression is parenthesized as 3 * (5 / 2), it is evaluated as:
  • 3 * (5 / 2)
  • 3 * 2
  • 6

Logical OR: ||

• a || b returns 1 if either a or b are non-zero, and returns 0 otherwise
• 0 || 0 || 1 returns 1
• 0 || 0 || 0 returns 0
• if a is set to 0, (a-- || ++a || a++ || a++ || --a) returns 1 and sets a to 2 because:
  • a-- sets a to -1 and returns 0, so evaluation moves on to:
  • ++a sets a to 0 and returns 0, so evaluation moves on to:
  • a++ sets a to 1 and returns 0, so evaluation moves on to:
  • a++ sets a to 2 and returns 1, so evaluation stops
  • leaving the final --a untouched

Logical AND: &&

• a && b returns 1 if both a and b are non-zero, and returns 0 otherwise
• 1 && 1 && 0 returns 0
• 1 && 1 && 1 returns 1
• similar to logical OR, evaluation stops at the first 0 result

Equality and Inequality: == and !=

• a == b returns 1 if both a and b
• a != b returns 1 if a and b do not hold the same value, and returns 0 otherwise
• 1 == 0 returns 0 and 1 != 0 returns 1
• 17 == 17 returns 1 and 17 != 17 returns 0
• is almost never a good idea to use == or != when comparing floating-point values

Aritmetic Relations: >, <, >= and <=

• a > b returns 1 if a is greater than b
• a < b returns 1 if a is less than b
• a >= b returns 1 if a is greater than or equal to b
• a <= b returns 1 if a is less than or equal to b
• note that order is important, and => and =< will cause errors

Logical NOT: !

• !a returns 1 if a is non-zero, and returns 0 otherwise

Bitwise OR: |

• the expression 9 | 3 is (1001 | 0011) in binary which evaluates to 1011, since the OR operator sets every result bit to 1 if it is set to 1 in either of the arguments.
  
  For instance, (0 | 0) is 0, but (0 | 1), (1 | 0), and (1 | 0) are all 1.

Bitwise AND: &

• 9 & 3 evaluates to 0001 or 1, since the AND operator only sets a result bit to 1 when both of the bits are set to 1.
  
  For instance, (1 & 1) is 1, but (0 & 0), (0 & 1), and (1 & 0) are all 0.

Bitwise XOR: ^

• 9 ^ 3 evaluates to 1010, since the XOR operator only sets a result bit to 1 when only 1 of the two bits is set to 1 and the other is set to 0.
  
  For instance, both (0 ^ 1) and (1 ^ 0) are 1 but both (0 ^ 0) and (1 ^ 1) are 0.

Left Shift and Right Shift: << and >>

• a = 2 << 3 sets a to 16 (because it shifts 000010 3 bits left to 010000)
• b = 13 >> 2 sets b to 3 (because it shifts 01110 2 bits right to 00011)
• Note that the result of a left or right shift request with a negative number or a number larger than the number of bits in a datatype are undefined

Bitwise NOT: ~

• ~a inverts all the bits
• a binary expression like ~0100101 evaluates to 1011010

Shift/Bitwise Operator types

• the shift and bitwise operators may only be used on integral types
• results of the shift and bitwise operators on signed integrals are not necessarily identical on all machines (those using one's complement and two's complement arithmetic will differ, for example)
• it is therefore recommended that these operators only be used on unsigned integers

Operator assignment: +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=

• a *= 2 multiplies a by 2 and stores the result in a
• a >>= 2 shifts a right 2 bits and stores the result in a

Variable/datatype size: sizeof

• the sizeof operator returns the size in units (where a unit is typically a byte) of its argument
• sizeof char (or sizeof(char)) returns 1
• sizeof(int) returns 4 on a machine which uses 32 bit ints
• int a; sizeof(a) returns 4 (for 32 bit ints)
• sizeof(1 + 3) returns 4 (for 32 bit ints)
• note that the expression itself is not evaluated so something like

    int a;
    a = 3;
    sizeof(a++);
  

  would leave a set to 3