GATE CS 1994 Q1.20 — Programming in C

To understand why the results differ, let us analyze how parameters are bound in both evaluation strategies:

• Call-by-Reference: The address of the actual parameter is evaluated once at the time of the function call. Inside the function, any access to the formal parameter directly uses this pre-computed address.
• Call-by-Name: The actual parameter expression is textually substituted for the formal parameter. It is re-evaluated every time the formal parameter is accessed or modified during execution.

Example Demonstration

Suppose we have a global index variable $i$, an array $A$, and a function foo(x):

int i = 1;
int A[5] = {10, 20, 30, 40, 50};

void foo(int x) {
    i = 2;
    x = 99;
}

foo(A[i]); // Passing an array element

1. Under Call-by-Reference:

• When foo(A[i]) is called, $i = 1$, so the address of $A[1]$ is passed.
• Inside foo, i is updated to $2$.
• The assignment x = 99 writes directly to the reference of $A[1]$.
• Result: $A[1]$ becomes $99$.

2. Under Call-by-Name:

• The formal parameter x is textually replaced by A[i].
• Inside foo, the body effectively becomes:

  i = 2;
  A[i] = 99; // x is replaced by A[i]
  

• Since $i$ was updated to $2$ in the first step, the assignment A[i] = 99 evaluates to A[2] = 99.
• Result: $A[2]$ becomes $99$, while $A[1]$ remains unchanged.

Since the index variable of the array element can change inside the function, passing an array element (Option C) can yield different results under the two parameter-passing techniques.