Functions and parameter passing

Why it exists

A function is a named piece of code you can reuse, but the real question is what the function can see and change. The caller and the callee are separate worlds, each with its own local variables. The main bridges are the arguments going in and the return value coming out (plus any global variable or pointed-to object both sides can reach). GATE questions on this topic check whether you know exactly what crosses that bridge: a copy of a value, or the address of something.

Prerequisites

Precise definitions

• Function definition. The return type, name, parameter list and body. Declaration (prototype) gives only the signature, so that calls can be checked before the definition: int max(int a, int b);.
• Formal parameters are the names in the definition (x, y). Actual parameters (arguments) are the expressions in the call (a, b + 1).
• Call by value. C always passes arguments by value: the value of each argument expression is computed and copied into the callee's formal parameter, which is a brand new local variable in the callee's frame. Changing the parameter changes only that copy.
• Simulating call by reference. To let a function change the caller's variable a, the caller passes &a, the address of a. The pointer parameter is itself a copy, but both the copy and the original point to the same object, so writing through it (*p = ...) changes a.
• Arrays as parameters. Two separate rules combine. At the call, an array argument is converted to a pointer to its first element. In the definition, a parameter declared as an array is adjusted to a pointer, so void f(int a[]) is exactly void f(int *a). The callee therefore receives an address, not a copy of the array, so element changes are visible to the caller. Inside the function, sizeof a is the size of a pointer, not the size of the array.
• Return value. return expr; copies the value of expr back to the caller (converted to the declared return type). If control reaches the closing } of a non-void function and the caller uses the returned value, the behaviour is undefined (main is the exception: reaching its } returns 0).
• Argument evaluation order is unspecified, and the arguments are fully evaluated (a sequence point) before the call happens.

How it works

First, plain call by value. Step through swap(a, b). Watch which variables change: only x and y in swap's own frame. When the call returns, the frame disappears and a and b are exactly as they were.

Now pass addresses. The parameters x and y are still copies, but they are copies of pointers, and each arrow leads back into main's frame. Writing through the arrows changes a and b, and those changes survive the return.

In the usual implementation this is what an activation record is: a block holding the parameters, the locals and the return address, pushed when the call starts and popped when it ends. (C itself only promises the behaviour; real compilers may pass some arguments in registers or remove frames by inlining.) That is also why recursion works: every call gets its own copies.

Worked examples

#include <stdio.h>
 
void swap(int x, int y) {
    int t = x;
    x = y;
    y = t;
}
 
int main(void) {
    int a = 1, b = 2;
    swap(a, b);
    printf("%d %d\n", a, b);
    return 0;
}

1 2

#include <stdio.h>
 
void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}
 
int main(void) {
    int a = 1, b = 2;
    swap(&a, &b);
    printf("%d %d\n", a, b);
    return 0;
}

2 1

#include <stdio.h>
 
void bump(int a[], int n) {
    for (int i = 0; i < n; i++) a[i]++;
    printf("%zu\n", sizeof a);
}
 
int main(void) {
    int v[3] = {1, 2, 3};
    bump(v, 3);
    printf("%d %d %d\n", v[0], v[1], v[2]);
    printf("%zu\n", sizeof v);
    return 0;
}

8
2 3 4
12

#include <stdio.h>
 
void f(int x, int *p, int a[]) {
    x = 10;
    *p = 20;
    a[0] = 30;
    p = &x;
}
 
int main(void) {
    int x = 1, y = 2, a[2] = {3, 4};
    f(x, &y, a);
    printf("%d %d %d\n", x, y, a[0]);
    return 0;
}

1 20 30

#include <stdio.h>
 
int a = 1, b = 2;
 
void set_copy(int *p) {
    p = &b;
}
 
void set_real(int **pp) {
    *pp = &b;
}
 
int main(void) {
    int *p = &a;
    set_copy(p);
    printf("%d ", *p);
    set_real(&p);
    printf("%d\n", *p);
    return 0;
}

1 2

Cheat box

Traps and GATE patterns

Other things examiners twist:

• Passing a struct by value copies the whole struct, including any array inside it, so the callee's changes are lost. This is the one way to pass an array "by value".
• A function name that is not the operand of & or sizeof is converted to a pointer to the function, which is how function pointers work.
• main may be called recursively in C (this is not allowed in C++), though it is rarely sensible.

Connections

The frame the animation draws is exactly the activation record a compiler designs, and the rules for how parameters are handed over (by value, by reference, by value-result, by name) are compared in the parameter passing modes of runtime environments. The same machinery makes recursion possible.

PYQs

Consider the following C program:
#include <stdio.h>
int g(int n) {
    return (n+10);
}
int f(int n) {
    return g(n*2);
}
int main() {
    int sum, n;
    sum=0;

    for (n=1; n<=3; n++)
        sum += f(n);

    printf("%d", sum);
    return 0;
}

The
output
of
the
given
C
program
is________________  (Answer in integer)

Consider the following ANSI C function :
int SimpleFunction(int Y[], int n, int x)
{
  int total = Y[0], loopIndex;
  for (loopIndex=1; loopIndex<= n –1; loopIndex++)

  total = x * total + y[loopIndex];
  return total;
}
Let Z be an array of 10 elements with Z[i]=1, for all i
such that 0 <= i <=9
The value returned by SimpleFunction(Z, 10, 2) is
_______

Consider the following C Functions.

int tob (int b, int* arr) {
    int i;
    for (i = 0; b >0; i++) {
        if (b % 2)
            arr[i] = 1;
        else arr[i]=0;
            b= b /2;
        }
    return (i);
}

The value returned by pp (3,4) is ____.

Consider the following C program:
 #include <stdio.h>
 int jumble (int x, int y) {
    x = 2 * x + y;
    return x;
}
int main ()  {
     int x=2, y=5;
     y = jumble (y, x);
     x = jumble (y, x);
     printf ("%d \n", x);
      return 0;
}
The value printed by the program is ______.

The value printed by the following program is
__________.

void f(int* p, int m) {
 m = m + 5;
*p = *p + m;
return;
}
void main() {
int i=5, j=10;
f(&i, j);
printf("%d", i+j);
}

What does the following program print?
#include <stdio.h>
void f(int *p, int *q)
{
  p = q;
  *p = 2;
}
int i = 0, j = 1;
int main()
{
f(&i, &j);
printf("%d %d n", i, j);
getchar();
  return 0;
}

Consider the program below:

#include <stdio.h>

int fun(int n, int *f_p) {

int t, f;

if (n <= 1) {

*f_p = 1;

return 1;

}

t = fun(n - 1, f_p);

f = t + *f_p;

*f_p = t;

return f;

 }

int main() {

 int x = 15;

 printf("%d\n", fun(5, &x));

 return 0;

}

The value printed is:

What is printed by the following C program?

int f(int x, int *py, int **ppz)

{

int y, z;

**ppz += 1;

z = **ppz;

*py += 2;

y = *py;

x += 3;

return x + y + z;

}

void main()

{

int c, *b, **a;

c = 4;

b = &c;

a = &b;

printf("%d", f(c, b, a));

}

Consider the following C-program:

 double foo(double);   /* Line 1 */

 int main()

{

 double da, db;

 // input da

 db = foo(da);

}

double foo(double a)

{

 return a;

}

The above code compiled without any error or
warning. If Line 1 is deleted, the above code will
show:

Self-check

#include <stdio.h>
 
void inc(int n) {
    n++;
}
 
int main(void) {
    int k = 5;
    inc(k);
    inc(k);
    printf("%d\n", k);
    return 0;
}

5

#include <stdio.h>
 
void inc(int *n) {
    (*n)++;
}
 
int main(void) {
    int k = 5;
    inc(&k);
    inc(&k);
    printf("%d\n", k);
    return 0;
}

7

#include <stdio.h>
 
void show(int a[100]) {
    printf("%zu ", sizeof a);
}
 
int main(void) {
    int arr[100];
    show(arr);
    printf("%zu\n", sizeof arr);
    return 0;
}

8 400

Revision card

References