Nt1310 Unit 6 Assignment

An assignment statement is one, which assigns a value to the variable. For example, if we have n = 6; it means the value 6 is assigned to the variable n.
Also, the value of the variable may differ depending on the assignment statement. For example, if we have the assignment statement as,
n = n – 1;
In this case, it gives n the value 5.
Syntax:
Thus, the general form or the syntax for the assignment statement is given as:
variable = expression;
Note that the variable has to be declared and expression has to produce a value as the output. Also, if you observe the equal to sign is used as the operator for assignment.
To avoid confusions, different programming languages use different operator such as, the assignment operator “: =” is used in

case of ALGOL 60 and Ada.
Assignment statement can be written using the following assignment operators:
1. Simple Assignment operators
2. Compound Assignment operators
3. Unary Assignment operators
Simple Assignment operators: Among various operators, one of the simple assignment operator is “=”, which assigns value on its right to the operand on left. Till now we were discussing about simple assignment operator. Let us see some more example that uses simple assignment operator:
The following two examples of C code uses simple assignment operator:
#include
int main()
{
int value;
value = 25;
return (0);
} if(value = 5)
printf("True");
else
printf("False");
Here the value 25 is assigned to variable that is value. Here the number 5 is assigned to value within if statement.

Compound Assignment operators:
The Table shows various types of Assignment operators. A compound assignment is one in which bitwise, shift or arithmetic operations are carried out before the result is stored. Except for the ‘=’ operator, other operators are all compound assignment operators in the table.
Syntax:
The general form for compound Assignment operators is given as:
a = a + b … (1)
or
a += b … (2)
If you observe the above assignment (1), the operand on left (a) will also appear as operand on right (a). Note, that the operand on left, if it’s a pointer type then the operand on right should also be a pointer type or constant expression and if the operand on left is integral then operand on right need not be a pointer type.
The concept of compound assignment operator works with all programming languages such as C, Perl, JavaScript and so on. However, it was introduced for the first time by ALGOL 68. Let us look at the syntax in case of the following example,
count += value;
The above assignment can also be written as shown below and it has the same meaning:
count = count + value;
Let us assign some values and see how the assignment operator works, for example:
Integer : : Counter = 0 //Initializing counter to zero and is an integer
Counter = Counter + 1 //Assignment statement 1
Counter = Count + 2 //Assignment statement 2

In the above example, the assignment statement 1 computes the sum of value present in Counter and numeric value 1, then the new value is stored in Counter, that is
0 + 1 = 1
So, the present Counter value is 1 and this goes to the second statement, and now it once again computes the new value of Counter as,
1 + 2 = 3
3 is the new Counter value and is assigned to the Counter back, erasing the previous one.

Mixed mode Assignment
Programming languages allow you to combine Real and Integer variables or constants in a single expression. Such arithmetic expressions are known as mixed mode arithmetic expressions. For example, in the following expressions the iValue1 is allowed as integer as

int:
int iValue1 = 1;
iValue1 + 1.0
An expression has at least one operator and two operands.

As we can see in the above example, the iValue1 and 1.0 are the two operands and which are not of the same type. One is the integer and the other is a double precision floating point value. Therefore, the above expression is an example of mixed mode expression.
A double precision floating point value generally takes 64 bits of memory space and can denote values of dynamic range using floating point.
In case of mixed mode expressions, usually the integer is converted into real before performing computations. Hence, mixed mode expression always result in a Real type. Even in case of the above example, the iValue1 get converted to double before computation begins. In most of the iterative computations double works best to maintain the accuracy of results.
Rules
Following are some of the basic rules to be followed while evaluating mixed mode expressions:
1. Evaluate the expressions always from left to right. The priority of an operator in the expression is determined with respect to the next one in the expression.
For example, the following expression must be scanned from left to

right.
2* 3 +1
In this scanning, the very first operator encountered is * and it has the highest priority hence, calculated first when compared to the next operator +.
Thus, first 2* 3 is evaluated, which is 6 and then 6 + 1 = 7.
2. Once the operator is located,
a. check if both the operands are of similar type, if yes then evaluate the result
b. If one operand is real and other is integer, then the integer is converted into real. This is done by adding .0 in the end of the integer and the result is now evaluated, which will be of real type.
c. In case we have b**n, where b is real and n is integer (positive) then you can compute as 2.5* 4 as 2.5*2.5*2.5*2.5.

Thus, assignment statements can be of mixed mode. For example:
int x, y;
float z;
z = x * y;
The following C code shows the use of mixed mode:
#include
#include
int main()
{
int p=20, q=5;
float r;
clrscr();
r=p/q;
printf("r value is %f", r);
getch();
}

Output:
r value is 4.000000

In case of programming languages such as, C, C++ and Fortran the coercion rules are used in case of mixed mode assignment, whereas widening assignment coercions are carried out in case of Java. However, there are no assignment coercion in case of Ada.