Question

1. f (m, n) m- n* 10; main int z[] 10, 20, 30; print(z [w], z[0]); Given the code above, what is the output of the program if the values are passed by: a) Value. b) Value-result and address of z[ c) Reference. d) Name is computed at the time of the cal Note: The order of evaluating the parameters of a subprogram are from left to right.)

Answer 1

1) Using pass by value:

Output: 10 10

Explanation: Here the value of w is 0 so z[w] becomes equivalent to z[0] that is 10. Since we are using pass by value mechanism, therefore, the actual parameters that are z[w] and z[0] will be copied to the formal parameters m and n but since m and n are the copies so any changes made on m and n will not be reflected to z[w] and z[0]. Therefore output becomes 10 and 10.

2) value result and address of z[w]

If the value of z[w] is returned by the procedure and is computed at the time of call, in this fashion given below:

int f(int m,int n)

{

int w;

w = w + 1;

n = 3;

m = n*10;

return m;

}

int main()

{

int w = 0;

int rv;

int z[] = {10,20,30};

rv = f(z[w],z[0]);

printf(rv);

printf(z[w],z[0]);

}

then,

Output : 30 10 10 //address return value of z[w] and value of z[w] and z[0]

Explanation: Returning m will return m = 3*10

Rest of the part is same as explanied for the sub question 1 (return by value mechanism).

3) Passed by Reference

Output : 30 30

Explanation; Since we are passing the reference of the z[w] and z[0] to m and n, So any changes made on to m and n will be reflected on z[w] and z[0]. Since we are manipulating the values of m and n in the definition of our function f(), the value of m and n becomes 30 and 30 and consequently, z[w] and z[0] becomes 30 and 30.

4) Passed by name

Output ; 30 30

Explanation: Passing by name is somewhat equivalent to passing by reference. "But they are not the same". When we use passing by name mechanism what happens is that the actual parameters are substituted into the function definition and it is allowed to read as well as write the actual parameters within the function body itself.

In this case z[w] and z[0] if are "passed by name" then m and n are substituted by z[m] and z[0] and all the operations that happen inside the function body on m and n are equivalent to operations done on z[w] and z[0] . Therefore are directly reflected on z[w] and z[0].

Therefore the value becomes 30 30