# c programming Operators

### c programming Operators

Operators are ‘C’ tokens which can join together individual constants, variables array elements, and function references. Operators act upon data items called as operands.

#### Classification

• Arithmetic operators
• Relational operators
• Logical operators
• Assignment operator
• Increment and decrement operator
• Conditional operator
• Bitwise operator
• Special operator
##### Arithmetic Operators
 Arithmetic operator Meaning + Adding or unary plus – Subtraction or unary minus * Multiplication / Division % Modulo division
• For arithmetic operations, operands must be numeric values.
• Here modulo division produces reminder of integer division.
• arithmetic operations are classified as
• Integer arithmetic
• Real arithmetic
• Mixed mode arithmetic

Integer arithmetic: Both the operands are an integer in integer arithmetic. It always yields an integer value.
Ex: `int a=10,b=5;  a+b;  a-b; a*b; a/b ; a%b etc.`

Real arithmetic: Both the operands are real in real arithmetic. It yields real values as a result. It cannot be applied to the % operator.
Ex:

```float a=10.0, b=5.0;
a+b=10.0+5.0=15.0 i.e. 15.000000
a-b= 10.0-5.0 =5.0 i.e. 5.000000
a*b= 10.0*5.0 =50.0 i.e. 50.000000
a/b= 10.0/5.0 = 2.0 i.e. 2.000000
a%b=10.0%5.0 (invalid expression)```

Mixed Mode Arithmetic: when one operand is an integer and other is real it is known as mixed mode arithmetic. Here the result will always be real.
Ex:

```int a=10;
float b=5.0;
a+b=10+5.0=15.0
a-b = 10-5.0 =5.0
a*b = 10*5.0 =50.0
a/b = 10/5.0 = 2.0
a%b=10%5.0 (invalid expression)```
##### Relational Operators

These are used to compare two quantities. These operators always return 1(true) or 0 (false). If the expression is true then it returns with 1 else 0

 Relational Operator Action < is less than <= is less than or equal to > is greater than >= is greater than or equal to == is equal to != is not equal to

 Expression Result 10<5 0 (false) 10>5 1 (true) 10==15 0 (false) 10!=15 1 (true) (10+5)==(3*5) 1 (true)
##### Logical Operators
 logical Operator Action && logical AND || logical OR ! logical NOT
• Logical expression combines two or more relational expressions.
• Logical operators are used to testing more than one condition and make a decision.
• Logical AND: The result of logical AND expression will be true only when both the relational expression is true.

Syntax:`exp1 && exp2;`

• Logical OR: The result of logical OR expression will be false only when both relational expressions are false.

Syntax: `exp1 || exp2;`

• Logical NOT: The result of the expression will be true if the expression is false and vice versa

.Syntax:`!exp1;`
Ex:

```int a=10,b=15, c=20,i;
i= (a>b) && (b<c); //The value of i in this expression will be 0.
i= (a<b) && (b<c); //The value of i in this expression will be 1.
i= (a>b) || (b<c); //The value of i in this expression will be 1.
i= ! (a>b); //The value of i in this expression will be 1.```
##### Assignment Operators

The operators are used to assign the result of an expression to a variable
Syntax: `Variable = exp;`

 Assignment Operator  Ex: int a=10,b=5; Action a=a+1; or a+=1; adds 1 to a and assigns the value to a a=a-1; or a-=1; decrements a by 1 and assigns the value to a a=a/(b+1) or a/=b+1; divides a by (b+1) and assigns the result in a a*=b+2; or a=a*(b+2) multiplies (b+2) with a and assigns the result in a

Increment and Decrement operators

• These operators are represented as ‘++’ and ‘–’.
• ++ Increments operand by 1 and –- decrement the value by 1.
• These are the unary operators and takes the following forms,
 Operator (int a,b) Action Result a=1;  b=++a; pre-increment increments a value by 1 and assigns the value to b. i.e., a=2 and b=2 a= 1;  b=a++; post-increment Assigns the value to b then increments a value by 1. i.e., a=2 and b=1 a=2;  b=–a; pre-decrement decrements a value by 1 and assigns the value to b. i.e., a=1 and b=1 a=2;  b=a–; post-decrement Assigns the value to b then decrements a value by 1. i.e., a=1 and b=2
##### Conditional Operator
• It is also known as a ternary operator
Syntax: `exp1 ? exp2 : exp3;`
Where exp1, exp2, and exp3 are expressions

Ex:

```int a=5,b=10,c=15,y;
y=(a>b) ? b : c; //The value of y is 15
y=(a<b) ? b : c; //The value of y is 10```

Ex2:

```/* Greatest of three numbers using conditional operation */
int a=5,b=10,c=15,y;
y=(a>b && a>c) ? a: (b>c) ? b: c; //Here greatest of three numbers is stored in x;```
##### Bitwise Operators

Bitwise operators are similar to that of logical operators except that they work on binary bits. When bitwise operators are used with variables, they are internally converted to binary numbers and then bitwise operators are applied on individual bits.

Bitwise operators do manipulation on bit stored in memory. These operators work with char and int type only. They cannot use floating point numbers.

 Bitwise Operators Action ~ 1’s compliment | Bitwise OR ^ Bitwise exclusive OR & Bitwise AND << Left shift >> Right shift

Ex:

```int a=10,b=8; //Assum that int size is 2 bytes
/* The equivalent binary value of a is 0000 0000 0000 1010
The equivalent binary value of b is 0000 0000 0000 1000
*/
printf("%d", a & b); // The value of a & b = 0000 0000 0000 1000 i.e.,8

printf("%d", a|b); // The value of a | b = 0000 0000 0000 1010 i.e., 10

printf("%d", a^b); //The value of a ^ b= 0000 0000 0000 0010 i.e., 2

printf("%d" ,a<<2);
/*
a(10) binary is 0000 0000 0000 1010 a<<2.
It left shift the binary bits twice. i.e.,0000 0000 0010 1000 i.e. 40 */

printf("%d", a>>2);
/*
a(10) binary is 0000 0000 0000 1010 a>>2.
It right shifts the binary bits twice. i.e., 0000 0000 0000 0010 i.e. 2
*/```
##### Special Operator

There are some special operators available in ‘C’ such as sizeof operator and member selection operators (. and →).

sizeof Operator: It returns numbers of bytes the operand occupies; operand may be a variable, a constant, or a data type qualifier.
Syntax: `sizeof(operand)`
Ex:

```int y;
y= sizeof (int); //here value of y will be 2 byte it its 16bit compiler```

Member Operators: These are used to access members of structure and unions.

### Operators priority wise

 Operators Operation Clubbing Priority ()[]->. Function callSquare bracketStructure operatorStructure operator Left to Right 1st +–++—!~*&sizeoftype Unary plusUnary minusIncrementDecrementNot operatorOnes complementPointer operatorAddress operatorSize of an objectType case Right to Left 2nd */% MultiplicationDivisionModular division Left to Right 3rd +_ AdditionSubtraction Left to Right 4th <<>> Left shiftRight shift Left to Right 5th <<=>>= Less thanLess than or equal toGreater thanGreater than or equal to Left to Right 6th ==!= EqualityInequality Left to right 7th & Bitwise AND Left to right 8th ^ Bitwise XOR Left to right 9th | Bitwise OR Left to right 10th && Logical AND Left to right 11th || Logical OR Left to right 12th ? : Conditional operator Right to left 13th =, +=,-=,*=, /=, %=, &=,^=, |=, <<=, >>= Assignment operators Right to left 14th

### Expressions

An expression in C is constructed using operators, variables and or constants.

Ex:

```x+y*3.5
x<y x<y && x>5``` error: Content is protected !!