 ## Operators In C Language

### Operators:

One of the most important features of C is that it has a very rich set of built in operators including arithmetic, relational, logical, and bitwise operators.

### Assignment Operator in C Language:

Syntax
```int x ;
x = 20 ;```

Some common notation :-

Syntax
```lvalue  --  left hand side of an assignment operation
rvalue -- right hand side of an assignment operation```

Type Conversions :- The value of the right hand side of an assignment is converted to the type of the lvalue. This may sometimes yield compiler warnings if information is lost in the conversion.

For Example :-

Syntax
```int x ;
char ch ;
float f ;```

ch = x ; /* ch is assigned lower 8 bits of x, the remaining bits are discarded so we have a possible information loss */

x = f ; /* x is assigned non fractional part of f only within int range, information loss possible */

f = x ; /* value of x is converted to floating point */

Multiple assignments are possible to any degree in C, the assignment operator has right to left associativity which means that the rightmost expression is evaluated first.

For Example :-

Syntax
`x = y = z = 100 ;`

In this case the expression z = 100 is carried out first. This causes the value 100 to be placed in z with the value of the whole expression being 100 also. This expression value is then taken and assigned by the next assignment operator on the left i.e. x = y = ( z = 100 );

### Arithmetic Operators in C Language:

+ - * / --- same rules as mathematics with * and / being evaluated before + and -.% -- modulus / remainder operator

For Example :-

Syntax
```int a = 5, b = 2, x ;
float c = 5.0, d = 2.0, f ;
x = a / b ;    //  integer division, x = 2.
f = c / d  ;    //  floating point division, f = 2.5.
x = 5 % 2 ;    //  remainder operator, x = 1.
x = 7 + 3 * 6 / 2 - 1 ;// x=15,* and / evaluated ahead of + and -.```

Note that parentheses may be used to clarify or modify the evaluation of expressions of any type in C in the same way as in normal arithmetic.

Syntax
```x = 7 + ( 3 * 6 / 2 ) - 1 ;    // clarifies order of evaluation without penalty
x = ( 7 + 3 ) * 6 / ( 2 - 1 ) ;    // changes order of evaluation, x = 60 now.```

### Increment and Decrement Operators in C Language:

There are two special unary operators in C, Increment ++, and Decrement -- , which cause the variable they act on to be incremented or decremented by 1 respectively.

Syntax
```For Example :-
x++ ;  /* equivalent to x = x + 1 ; */```

++ and -- can be used in prefix or postfix notation. In prefix notation the value of the variable is either incremented or decremented and is then read while in postfix notation the value of the variable is read first and is then incremented or decremented.

Syntax
```For Example :-
int i,  j = 2 ;
i = ++ j  ;    /* prefix  :-   i has value 3, j has value 3  */
i = j++ ;    /* postfix  :-  i  has value 3, j has value 4   */```

### Special Assignment Operators in C Language:

Many C operators can be combined with the assignment operator as shorthand notation

Syntax
```For Example :-
x = x + 10 ;
can be replaced by
x += 10 ;
Similarly for  -=, *=,  /=, %=, etc.```

These shorthand operators improve the speed of execution as they require the expression, the variable x in the above example, to be evaluated once rather than twice.

### Relational Operators in C Language:

The full set of relational operators are provided in shorthand notation

Syntax
`>    >=    <    <=    ==    !=`
Syntax
```For Example :-
if ( x == 2 )
printf( “x is equal to 2”) ;```

### Logical Operators in C Language:

Syntax
```&&    --    Logical  AND
| |     --    Logical  OR
!    --    Logical NOT```
Syntax
```For Example :-
if (  x >= 0 && x < 10  )
printf( “ x is greater than or equal to zero and less than ten.” ) ;
``` NOTE : There is no Boolean type in C so TRUE and FALSE are deemed to have the following meanings. FALSE -- value zero TRUE -- any non-zero value but 1 in the case of in-built relational operations

Syntax
```For Example :-
2 > 1        -- TRUE  so expression has value 1
2 > 3        -- FALSE so expression has value 0
i = 2 > 1  ;    --  relation is TRUE -- has value 1, i is assigned value 1  ```

NOTE : Every C expression has a value. Typically we regard expressions like 2 + 3 as the only expressions with actual numeric values. However the relation 2 > 1 is an expression which evaluates to TRUE so it has a value 1 in C. Likewise if we have an expression x = 10 this has a value which in this case is 10 the value actually assigned.

NOTE : Beware of the following common source of error. If we want to test if a variable has a particular value we would write for example

Syntax
```if ( x == 10 )  …
But if this is inadvertently written as
if ( x = 10 ) …```

this will give no compilation error to warn us but will compile and assign a value 10 to x when the condition is tested. As this value is non-zero the if condition is deemed true no matter what value x had originally. Obviously this is possibly a serious logical flaw in a program.

### Bitwise Operators in C Language:

These are special operators that act on char or int arguments only. They allow the programmer to get closer to the machine level by operating at bit-level in their arguments.

Syntax
```&     Bitwise AND        |    Bitwise OR
^    Bitwise XOR        ~    Ones Complement
>>    Shift Right        <<    Shift left```

Recall that type char is one byte in size. This means it is made up of 8 distinct bits or binary digits normally designated as illustrated below with Bit 0 being the Least Significant Bit (LSB) and Bit 7 being the Most Significant Bit (MSB). The value represented below is 13 in decimal.

Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
0 0 0 0 1 1 0 1

An integer on a 16 bit OS is two bytes in size and so Bit 15 will be the MSB while on a 32 bit system the integer is four bytes in size with Bit 31 as the MSB.

### Bitwise AND, (&) :

RULE : If any two bits in the same bit position are set then the resultant bit in that position is set otherwise it is zero.

Syntax
```For Example :-
1011 0010    (178)
&     0011 1111     (63)
=     0011 0010     (50)```

### Bitwise OR, (|) :

RULE : If either bit in corresponding positions are set the resultant bit in that position is set.

Syntax
```For Example :-
1011 0010        (178)
|      0000 1000        (63)
=     1011 1010        (186)```

### Bitwise XOR, (^) :

RULE : If the bits in corresponding positions are different then the resultant bit is set.

Syntax
```For Example :-
1011 0010        (178)
^      0011 1100        (63)
=     1000 1110        (142)```

### Shift Operators, (<< and >>) :

RULE : These move all bits in the operand left or right by a specified number of places.

Syntax
```variable << number of places
variable >> number of places```

For Example :- 2 << 2 = 8 i.e. 0000 0010 becomes 0000 1000

NOTE : shift left by one place multiplies by 2 shift right by one place divides by 2

### Ones Complement in C Language:

RULE : Reverses the state of each bit.

Syntax
```For Example :-
1101 0011 becomes 0010 1100``` NOTE : With all of the above bitwise operators we must work with decimal, octal, or hexadecimal values as binary is not supported directly in C.

The bitwise operators are most commonly used in system level programming where individual bits of an integer will represent certain real life entities which are either on or off, one or zero. The programmer will need to be able to manipulate individual bits directly in these situations.

A mask variable which allows us to ignore certain bit positions and concentrate the operation only on those of specific interest to us is almost always used in these situations. The value given to the mask variable depends on the operator being used and the result required.

Syntax
```For Example :- To clear bit 7 of a char variable.
char ch = 89 ;        // any value
char mask = 127 ;    // 0111 1111
ch = ch & mask ;    // or  ch &= mask ;```
Syntax
```For Example :- To set bit 1 of an integer variable.
int i = 234 ;        // any value
int mask = 2 ;        // a 1 in bit position 2

### Implicit & Explicit Type Conversions in C Language:

Normally in mixed type expressions all operands are converted temporarily up to the type of the largest operand in the expression.

Normally this automatic or implicit casting of operands follows the following guidelines in ascending order.

 long double double float unsigned long long unsigned int signed int
Syntax
```For Example :-
int i ;
float f1, f2 ;
f1 = f2 + i ;```

Since f2 is a floating point variable the value contained in the integer variable is temporarily converted or cast to a floating point variable also to standardise the addition operation in this case. However it is important to realise that no permanent modification is made to the integer variable.

Explicit casting coerces the expression to be of specific type and is carried out by means of the cast operator which has the following syntax.

Syntax
`( type )  expression`

For Example if we have an integer x, and we wish to use floating point division in the expression x/2 we might do the following

Syntax
`( float ) x  /  2`

which causes x to be temporarily cast to a floating point value and then implicit casting causes the whole operation to be floating point division.

The same results could be achieved by stating the operation as

Syntax
`x  /  2.0`

which essentially does the same thing but the former is more obvious and descriptive of what is happening. NOTE : It should be noted that all of these casting operations, both implicit and explicit, require processor time. Therefore for optimum efficiency the number of conversions should be kept to a minimum.

### Sizeof Operator in C Language:

The sizeof operator gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types as we will see later on).

The expression is either an identifier or a type-cast expression (a type specifier enclosed in parentheses).

Syntax
`sizeof ( expression )`
Syntax
```For Example :-
int x , size ;
size = sizeof ( x ) ;
printf(“The integer x requires %d bytes on this machine”, size);
printf( “Doubles take up %d bytes on this machine”, sizeof ( double ) ) ;```

### Precedence of Operators in C Language:

When several operations are combined into one C expression the compiler has to rely on a strict set of precedence rules to decide which operation will take preference. The precedence of C operators is given below.

Precedence Operator Associativity
Highest ( ) [ ] -> . left to right
! ~ ++ -- +(unary) -(unary) (type) * & sizeof right to left
* / % left to right
+ - left to right
<< >> left to right
< <= > >= left to right
== != left to right
& left to right
^ left to right
| left to right
&& left to right
|| left to right
? : left to right
= += -= *= /= %= &= ^= |= <<= >>= right to left
Lowest , left to right

Operators at the top of the table have highest precedence and when combined with other operators at the same expression level will be evaluated first.

Syntax
```For example take the expression
2 + 10 * 5 ;```

Here * and + are being applied at the same level in the expression but which comes first ? The answer lies in the precedence table where the * is at a higher level than the + and so will be applied first.

When two operators with the same precedence level are applied at the same expression level the associativity of the operators comes into play.

Syntax
```For example in the expression
2 + 3 - 4 ;```

the + and - operators are at the same precedence level but associate from left to right and so the addition will be performed first. However in the expression
x = y = 2;
as we have noted already the assignment operator associates from right to left and so the rightmost assignment is first performed. NOTE : As we have seen already parentheses can be used to supersede the precedence rules and force evaluation along the lines we require. For example to force the addition in 2 + 10 * 5 ; to be carried out first we would write it as (2 + 10) * 5;

#operators_in_C_language #Assignment_Operator_in_C_Language #operators_in_c # Arithmetic_Operators_in_C_Language #Increment_and_Decrement_Operators_in_C_Language #Special_Assignment_Operators_in_C_Language #Relational_Operators_in_C_Language #Bitwise_Operators_in_C_Language #Bitwise_AND #(&)_in_c #Bitwise_OR #(|)_in_c #Bitwise_XOR #(^)__in_c #Shift_Operators #(<<_and_>>)_in_c #Ones_Complement_in_C_Language #Implicit_&_Explicit_Type_Conversions_in_C_Language #Sizeof_Operator_in_C_Language #Precedence_of_Operators_in_C_Language #

### (New page will open, for Comment)

Not yet commented...