Operators in C Language

Operators in C Language
What is operator?
An operator is a symbol which helps the user to command the computer to do a certain mathematical or logical manipulations. Operators are used in C language program to operate on data and variables. The data items that operators act upon are called operands. Some operators require two operands, while others act upon only one operand.

Three things to know about operators are:
•    Function – what it does.

•    Precedence – in which order are operators combined.

•    Associativity – in which order operators of the same precedence are executed.

Operator precedence:
Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator:

For example x = 7 + 3 * 2; Here x is assigned 13, not 20 because operator * has higher precedence than + so it first get multiplied with 3*2 and then adds into 7.

Here operators with the highest precedence appear at the top of the table; those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Types of operators:

C has a rich set of operators which can be classified as

• Arithmetic operators

• Relational Operators

• Logical Operators

• Assignment Operators

• Increments and Decrement Operators

• Conditional Operators

• Bitwise Operators

Arithmetic operators:

All the basic arithmetic operations can be carried out in C. All the operators have almost the same meaning as in other languages. Both unary and binary operations are available in C language. Unary operations operate on a single operand, therefore the number 5 when operated by unary – will have the value –5.

+   For performing Addition
-   For performing Subtraction
/   For performing Division
*   For performing Multiplication
% Modulo for finding remainder in division operation.

If one or both operands represent negative values, then the addition, subtraction, multiplication and division operations will result in values whose signs are determined by the usual rules of algebra.
The interpretation of remainder operation is unclear when one of the operands is negative.
Operands that differ in type may undergo type conversion before the expression takes on its final value. The final result has highest precision possible, consistent with data types of the operands. The following rules apply when neither operand is unsigned.

•    If one operand is a floating point type and the other is a char or an int, the char/int will be converted to the floating point type of the other operand and the result will be expressed as such. So, an operation between an int and a double will result in double

•    If both operands are floating-point types with different precisions, the lower-precision operand will be converted to the precision of the other operand and the result will be expressed in this higher precision

Float & double → double

Float & long double → long double

Double & long double → long double

•    If neither operand is a floating point type or a long int, then both operands will be converted to int & the result will be int.

•    If neither operand is a floating point type but one is a long int, the other will be converted to long int & the result will be long int.

Integer Arithmetic:

When an arithmetic operation is performed on two whole numbers or integers than such an operation is called as integer arithmetic. It always gives an integer as the result. Let x = 27 and y = 5 be 2 integer numbers. Then the integer operation leads to the following results.

x + y = 32
x – y = 22
x * y = 115
x % y = 2
x / y = 5

In integer division the fractional part is truncated.

Floating point arithmetic:
When an arithmetic operation is preformed on two real numbers or fraction numbers such an operation is called floating point arithmetic. The floating point results can be truncated according to the properties requirement. The remainder operator is not applicable for floating point arithmetic operands.
Let x = 14.0 and y = 4.0 then
x + y = 18.0
x – y = 10.0
x * y = 56.0
x / y = 3.50

Mixed mode arithmetic:

When one of the operand is real and other is an integer and if the arithmetic operation is carried out on these 2 operands then it is called as mixed mode arithmetic. If anyone operand is of real type then the result will always be real thus 15/10.0 = 1.5.

Increment and Decrement Operators:
The increment and decrement operators are one of the unary operators which are very useful in C language. They are extensively used in for and while loops. The syntax of the operators is given below
1. ++ variable name
2. variable name++
3. – –variable name
4. variable name– –
The increment operator ++ adds the value 1 to the current value of operand and the decrement operator – – subtracts the value 1 from the current value of operand. ++variable name and variable name++ mean the same thing when they form statements independently, they behave differently when they are used in expression on the right hand side of an assignment statement.

Relational and logical operators:

Relational operators:

Often it is required to compare the relationship between operands and bring out a decision and program accordingly. This is when the relational operator comes into picture. C supports the following relational operators.




Operator
Meaning
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


It is required to compare the marks of 2 students, salary of 2 persons; we can compare those using relational operators. A simple relational expression contains only one relational operator and takes the following form.
exp1 relational operator exp2
Where exp1 and exp2 are expressions, which may be simple constants, variables or combination of them. Given below is a list of examples of relational expressions and evaluated values.
6.5 <= 25 TRUE
-65 > 0 FALSE
10 < 7 + 5 TRUE

Relational expressions are used in decision making statements of C language such as if, while and for statements to decide the course of action of a running program.

Logical Operators:

C has the following logical operators; they compare or evaluate logical and relational expressions.



Operator
Meaning
&&
Logical AND
||
Logical OR
!
Logical NOT



Logical AND (&&):

This operator is used to evaluate 2 conditions or expressions with relational operators simultaneously. If both the expressions to the left and to the right of the logical operator is true then the whole compound expression is true.
Example: a > b && x = = 10
The expression to the left is a > b and that on the right is x == 10 the whole expression is true only if both expressions are true i.e., if ‘a’ is greater than ‘b’ and x is equal to 10.

Logical OR (||)

The logical OR is used to combine 2 expressions or the condition evaluates to true if any one of the 2 expressions is true.
Example: a < m || a < n
The expression evaluates to true if any one of them is true or if both of them are true. It evaluates to true if ‘a’ is less than either ‘m’ or ‘n’ and when ‘a’ is less than both ‘m’ and ‘n’.

Logical NOT (!):
The logical not operator takes single expression and evaluates to true if the expression is false and evaluates to false if the expression is true. In other words it just reverses the value of the expression.
For example :!( x >= y) the NOT expression evaluates to true only if the value of x is neither greater than nor equal to y.

Bitwise operators:
C has a distinction of supporting special operators known as bitwise operators for manipulation data at bit level. A bitwise operator operates on each bit of data. Those operators are used for testing, complementing or shifting bits to the right on left. Bitwise operators may not be applied to a float or double. The Bitwise operators supported by C language are listed in the following table. Assume variable A holds 60 and variable B holds 13 then:


Assignment Operators:

 The Assignment Operator evaluates an expression on the right of the expression and substitutes it to the value or variable on the left of the expression.

Example: x = a + b

Here the value of a + b is evaluated and substituted to the variable x.
In addition, C has a set of shorthand assignment operators of the form.
var oper = exp;
Here var is a variable, exp is an expression and oper is a C binary arithmetic operator. The operator oper = is known as shorthand assignment operator

Example: x + = 1 is same as x = x + 1

The commonly used shorthand assignment operators are as follows

Shorthand assignment operators



Statement with simple assignment operator
Statement with
shorthand operator
a = a + 1
a += 1
a = a – 1
a -= 1
a = a * (n+1)
a *= (n+1)
a = a / (n+1)
a /= (n+1)
a = a % b
a %= b
 

Consider the following
m = 5;
y = ++m; (prefix)
In this case, the value of y and m would be 6

Suppose if we rewrite the above statement as
m = 5;
y = m++; (post fix)

Then the value of y will be 5 and that of m will be 6. A prefix operator first adds 1 to the operand and then the result is assigned to the variable on the left. On the other hand, a postfix operator first assigns the value to the variable on the left and then increments the operand.

Miscellaneous operators:

C supports some special operators of interest such as conditional operator, comma operator, size of operator, pointer operators (& and *) and member selection operators (. and ->).

The Comma Operator:

The comma operator can be used to link related expressions together. A comma-linked list of expressions is evaluated left to right and value of right most expression is the value of the combined expression.

For example the statement
value = (x = 10, y = 5, x + y);
First assigns 10 to x and 5 to y and finally assigns 15 to value. Since comma has the lowest precedence in operators the parenthesis is necessary. Some examples of comma operator are
In for loops: for (n=1, m=10, n <=m; n++,m++)
In while loops: While (c=get char (), c! = ‘10’)
Exchanging values
t = x, x = y, y = t;
The size of Operator:
The operator size of gives the size of the data type or variable in terms of bytes occupied in the memory. The operand may be a variable, a constant or a data type qualifier.
Example:
m = sizeof (sum);
n = sizeof (long int);
k = sizeof (235L);
The size of operator is normally used to determine the lengths of arrays and structures when their sizes are not known to the programmer. It is also used to allocate memory space dynamically to variables during the execution of the program.
Conditional or Ternary Operator:
The conditional operator consists of 2 symbols the question mark (?) and the colon (:)
The syntax for a ternary operator is as follows
exp1? exp2: exp3
The ternary operator works as follows, exp1 is evaluated first. If the expression is true then exp2 is evaluated & its value becomes the value of the expression. If exp1 is false, exp3 is evaluated and its value becomes the value of the expression. Note that only one of the expression is evaluated.
For example
a = 10;
b = 15;
x = (a > b)? a: b
Here x will be assigned to the value of b. The condition follows that the expression is false therefore b is assigned to x.
 

0 comments:

Post a Comment