C Operators

Back to A Brief Guide to C

• Operation Name: (operator)
  Optional explanation for really weird operators

  /* Code Sample */

Setting Values

• Equals, or "gets": =

  x = y;
  x = y = z = 5; /* they can also stack -- all the variables are set to the same value */

Comparing Values

• Is equal to: ==

  z = y == x; /* z gets '1' (true) if y is equal to x, '0' */ (false) otherwise

• Is not equal to: !=

  z = y != x; /* z gets '0' (false) if y is equal to x, '1' (true) otherwise */

• Is greater than: >

  z = y > x; /* z gets '1' (true) if y is greater than x, '0' (false) otherwise */

• Is greater than or equal to: >=

  z = y >= x; /* z gets '1' (true) if y is greater than or equal to x, '0' (false) otherwise */

• Is less than: <

  z = y < x;

• Is less than or equal to: <=

  z = y <= x;

• Logical And: &&

  z = y && x; /* z gets '1' if both y and x are not 0, '0' otherwise */

• Logical Or: ||

  z = y || x; /* z gets '1' if y or x are not 0, '0' otherwise */

• Logical Not: !
  This is useful for setting and comparing values.
  

  z = !x; /* z gets '1' if x is '0', '0' otherwise */

Arithmetic

• Addition: +

  z = y + x; /* z gets the value of y plus x */

  
  
• Subtraction: -

  z = y - x; /* z gets the value of y minus x */

  
  
• Multiplication: *

  z = y * x; /* z gets the value of y times x */

  
  
• Addition: /

  z = y / x; /* z gets the value of y divided by x */

  
  
• Modulus: %

  z = y % x; /* z gets the value of y modulo x */

  
  

Bit Twiddling

• Bitwise And: &
  This compares the bits in the two operands; for each bit, it and's the two bits. For instance, 12 (00001100 in binary) & 10 (00001010) = 8 (00001000). The fifth bit -- 8 -- was the only one which appeared in both operands, so it's the only one returned by the operator.
  

  z = y & x;

  
  
• Bitwise Inclusive Or: |
  This compares the bits in the two operands; for each bit, it or's the two bits. For instance, 12 (00001100 in binary) & 10 (00001010) = 14 (00001110). The fifth, sixth, and seventh bit appeared in the first or second operand, so they were returned by the operator.
  

  z = y | x;

  
  
• Bitwise Exclusive Or (aka Bitwise XOR): ^
  This compares the bits in the two operands; for each bit, it exclusive or's the two bits. For instance, 12 (00001100 in binary) & 10 (00001010) = 6 (00000110). The sixth and seventh bit appeared in either the first or second operand, so they were returned by the operator, while the fifth bit appeared in both, so a '0' was assigned in that place.
  

  z = y ^ x;

  
  
• Right / Left Shift: >> <<
  This shifts the bits a specific number of places right or left. Any bits that are shifted off the edge of the variable's memory space are lost. For instance, 7 (00000111) >> 2 = 1 (00000001) << 2 = 4 (00000100).
  

  z = y >> x;
  z = y << w;

  
  
• Bitiwise (One's) Complement: ~
  This does a one's complement on the operand, that is, it reverses all the bits. So, ~7 (00000111) = 248 (11111000)
  

  z = ~y

Operator-Equal Sign Operators: Don't Type 5 Characters Where 3 Will Do

• Addition: +=
  

  z += x; /* z gets z + x */

• Subtraction: -=
  

  z -= x; /* z gets z - x */

• Multiplication: *=
  

  z *= x; /* z gets z * x */

• Division: /=
  

  z /= x; /* z gets z / x */

• Modulus: %=
  

  z %= x; /* z gets z % x */

• Bitwise And: &=
  

  z &= x; /* z gets z & x */

• Bitwise Or: |=
  

  z |= x; /* z gets z | x */

• Bitwise XOr: ^=
  

  z ^= x; /* z gets z ^ x */

• Right / Left Shift: >>= <<=
  

  z >>= x;
  z <<= w;

Increment/Decrement: Don't Type 3 Characters Where 2 Will Do

• Pre/Post Increment: ++
  This operator does different operations depending on which side of the variable it is placed on. If it is placed before the variable, it increments (adds 1 to) the variable before any other operation in that statement. If it is placed after the variable, it increments the variable after everything else in that statement is finished. You may replace this operation with a += 1, placed before or after the statement depending on the operator's position with respect to the variable it modifies.
  

  z = x++; /* z gets x, then x is incremented by one */
  z = ++x; /* x is incremented, then z gets x */

• Pre/Post Decrement: --
  This behaves exactly like the ++ operator, except it decrements (decreases by one) its operand.
  

  z = x--; /* z gets x, then x is decremented */
  z = --x; /* x is decremented, then z gets x */

Other Operators

• Conditional: ?:
  Generally a bad thing to use, especially when you try to nest them. Try to limit these to really simple decisions.
  

  z == x ? z++ : x++; /* if z is equal to x, increment z; otherwise, increment x */

  
  
• Sizeof: sizeof()
  Returns the size, in bytes, of the operand. Useful for making your programs non-machine specific (since different processors may have different sized integers, for example).
  

  z = sizeof(y);

  
  
• Cast: (type)
  To cast a variable into a different type. For instance you might cast an int as a float when doing arithmetic with floats, or cast a float as an int when assigning its value to an int in order to suppress compiler warnings.
  

  int_z = (int)(float_y / (float) int_w);

Parentheses Change Precidence

• Parentheses: ()
  Please. Use parentheses rather than depend on the order of precedence. It makes your programs far more readable, and obfuscation is not your friend.
  

  z = (y + x) % w; /* z gets the value of the sum of y and x, modulo'd by w */

  
  

Operator Precedence

Highest precedence, which means it gets done first, is on top; lowest precedence is on the bottom. Operators with the same level of precedence get done left to right, except for the operator-equal sign (like +=) operators, which get done right to left. And none of this really matters since you are going to use parentheses rather than depend on precedence, right?

• ( ) -> .
• ++ -- ! ~ * & (type) sizeof()
• * / %
• + -
• << >>
• < <= > >=
• == !=
• &
• ^
• |
• &&
• ||
• ?:
• = += -= *= /= %= &= ^= |= <<= >>=
• ,