Unary Operators: take only one argument
e.g. unary -, unary +, ++, --, !
(-2), (+2), a++, a--, !done
Binary Operators: take two arguments
e.g. binary -, binary +, *, /, %, =, +=, -=, *=, /=, %=
(a - 2), (a + 2), (a * 2), (a / 2), (a % 2), (a = 2), (a += 2) ...
Assignment Statements: Used to set (or "assign") a value to a variable
Examples:
x = y; // The value of the variable x now has the same value as the variable y
x = x + 1; // The value of the variable x has been increased by one
x = x * x; // The value of the variable x has been set to the value of x squared
x = x - 1; // The value of the variable x has been decreased by one
x = x / 2; // The value of the variable x has been divided by 2
// ** please note: the resulting value of this operation will depend
// on the type of the variable x!
// If x is an integer, the operator / will truncate the result.
x = x % 2; // The % operator is not valid if either number is of type double/float.
// Assuming x is of type int (or char) the value of the variable x
// has been set to the remainder of x / 2
Special Assignment Operators: Combine Arithmetic with Assignment
x += 2; // this statement is equivalent to: x = x + 2;
x -= 2; // x = x - 2;
x *= 2; // x = x * 2;
x /= 2; // x = x / 2;
x %= 2; // x = x % 2; (not valid for type float or double)
Increment & Decrement Operators: Increase or Decrease a value by one
programming example:
void myfunction()
{
int a = 2, b = 1; // declare and initialize variables a and b
a++; // a now equals 3
b--; // b now equals 0
}
Boolean Operators: Evaluate expressions as true or false
A boolean expression may be simple or complex, but it always
evaluates to one of two values: true, or false.
Examples: y < z // if y < z, the value will be true
// else, the value will be false
y<=z // if y is less than OR equal to z
// the value will be true, else false
!(y>z) // if y if NOT greater than z, this
// value will be true, else false.
// equivalent to y <= z above.
!done // if the variable "done" = zero,
// then this expression will be true
a == b // if a and b are equal, the value will be true
// else the value will be false
** Please Note! The comparison operator for "equal to" is
'==' (two equal signs), NOT '=' alone
Combining boolean expressions using && and | |
Expressions can be made more complex by use of && and | |
&& => logical and operator (true only if both expressions are true)
| | => logical or operator (true if either one of the expressions is true)
Examples: (a < 5) && (b > 2) // this boolean expression will evaluate
// to true only if BOTH a < 5 is true, AND b > 2 is true
(a < 5) | | (b > 2) // this boolean expression will evaluate
// to true if EITHER a < 5 OR if b > 2
Bitwise Operators: Binary operators used for bit manipulation
e.g. & bitwise AND (e.g. n = n & 0177; // sets lower 7 bits to 1, all others to 0)
| bitwise OR (e.g. x = x | SET_ON; // sets x to same bits as SET_ON)
^ bitwise XOR
<< left shift (multiply)
>> right shift (divide)
~ one's complement (unary)
Operator Precedence: When an expression has more than one operator,
C has to determine the order in which to execute them.
This is called the "precedence."
Precedence of some basic operators:
++, --, !, (unary -), (unary +) // increment, decremement, not, unary ops
*, /, % // multiplication, division, modulo
+, - // addition and subtraction
<< >> // shift left, shift right
<, <=, >, >= // greater than, greater than or equal to, etc.
==, != // equal, not equal
& // bitwise and
^ // bitwise xor
| // bitwise or
&& // and
| | // or
=, +=, -=, *=, /=, %= // combined arithmetic/assignment operators
Parenthetical expressions "trump" other precedence
e.g. (a + b) * (c - d) will cause the expressions inside the parentheses
to be evaluated before multiplying the two values together
a + b * c - d would create an entirely different result, because
by default, b * c would be executed first.
control statements - switch
Switch case statements are a substitute for long if statements that compare a variable to several integral values
Syntax:
switch (n) { case 1: // code to be executed if n = 1; break; case 2: // code to be executed if n = 2; break; default: // code to be executed if n doesn't match any cases }
Example:
// Following is a simple C program // to demonstrate syntax of switch. #include <stdio.h> int main() { int x = 2; switch (x) { case 1: printf("Choice is 1"); break; case 2: printf("Choice is 2"); break; case 3: printf("Choice is 3"); break; default: printf("Choice other than 1, 2 and 3"); break; } return 0; }