User-Defined Functions

Instead of simply calling a pre-defined functions, C also allows us to write our own function. To put it simply, a function is a named abstraction of a computation. By calling the name of the function, we can perform the computation.

One of the important property we want in a function is modularity. This means that the same function should behave in the same way in different context. By context, we mean the set of mapping from name to values.

So how do we make a function behave differently? That's where the parameters come in. Parameters are the way we can communicate with a function. By starting with different values of parameters, the function may give different computation. The function then communicate back the result via the return value.

Without the parameters, the function is equivalent to a constant value. Take a function that always returns the value 42, for instance. Every call to this function can always be replaced by 42 without changing the behaviour of the program.

Defining a Functions

There are two parts to a function definition. The first is the declaration of function prototype and the second is the function definition that contains the computation.

1
2

<return type> <function name>(<parameter type>, <parameter type>, ...); // minimal definition
<return type> <function name>(<parameter type> <parameter name>, <parameter type> <parameter name>, ...);

1
2
3

<return type> <function name>(<parameter type> <parameter name>, <parameter type> <parameter name>, ...) {
  <function body>
}

Example

To illustrate this, let us try to solve the following problem:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>
#include <math.h>
#define PI 3.14159
int main(void) {
  double d1, // inner diameter
         d2, // outer diameter
         thickness, outer_area, inner_area, rim_area, volume;      

  // read input data
  printf("Enter inner diameter, outer diameter, thickness: ");
  scanf("%lf %lf %lf", &d1, &d2, &thickness);

  // compute volume of a washer
  outer_area = PI * pow(d2/2, 2);
  inner_area = PI * pow(d1/2, 2);
  rim_area = outer_area - inner_area;
  volume = rim_area * thickness;

  printf("Volume of washer = %.2f\n", volume);
  return 0;
}

But wait! We have not used a user-defined function! Note that the computation of the area of the circle is duplicated. In particular, if we wish to change the shape (e.g., to square where the input parameter now denotes the length of the sides) then we have to change both parts of the computation. This is prone to error.

Instead, we can abstract the computation of the area of a circle as a function. The function can be defined as follows:

1
2
3

double circle_area(double diameter) {
  return PI * pow(diameter/2, 2);
}

The resulting code will be the following. The function prototype, function definition and function calls are highlighted.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <stdio.h>
#include <math.h>
#define PI 3.14159

double circle_area(double);

int main(void) {
  double d1, // inner diameter
         d2, // outer diameter
         thickness, /* outer_area, inner_area, */ rim_area, volume;      
                    /* variables not needed    */

  // read input data
  printf("Enter inner diameter, outer diameter, thickness: ");
  scanf("%lf %lf %lf", &d1, &d2, &thickness);

  // compute volume of a washer
  rim_area = circle_area(d2) - circle_area(d1);
  volume = rim_area * thickness;

  printf("Volume of washer = %.2f\n", volume);
  return 0;
}

double circle_area(double diameter) {
  return PI * pow(diameter/2, 2);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Preprocessor directives
// e.g.: #include #define

// Function prototypes
// e.g.: double circle_area(double); <-- ends with semi-colon

int main(void) {
  // Variable declarations
  // e.g.: int x

  // Inputs
  // Computations
  // Outputs

  return 0;
}

// Function definitions
// e.g.: double circle_area(double x) { return ...; } <-- note the function body

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <stdio.h>
#include <math.h>
#define PI 3.14159

double circle_area(double diameter) { // prototype + definition --> definition
  return PI * pow(diameter/2, 2);
}

int main(void) {
  double d1, // inner diameter
         d2, // outer diameter
         thickness, /* outer_area, inner_area, */ rim_area, volume;      
                    /* variables not needed    */

  // read input data
  printf("Enter inner diameter, outer diameter, thickness: ");
  scanf("%lf %lf %lf", &d1, &d2, &thickness);

  // compute volume of a washer
  rim_area = circle_area(d2) - circle_area(d1);
  volume = rim_area * thickness;

  printf("Volume of washer = %.2f\n", volume);
  return 0;
}

Scope

C uses static scoping also called lexical scoping. There are three kinds of variables in C:

1. Global Variables
   • Variables declares outside of all functions.
   • The variables are available to all functions.
2. Local Variables
   • Variables declared inside a function, including the function parameters.
   • The variables are available only within the functions.
3. Static Variables
   • Variables declared inside a function, with a static keyword.
   • The variables are available only within the functions.
   • The values in the variables persist across function call.

We can visualise the global and local variables as a nested block of codes. However, we will exclude static variables from our discussion.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include <stdio.h>
int x = 2;
int adder(int);

int main(void) {
  int x = 3;
  printf("res = %d\n", adder(x));
  return 0;
}

int adder(int y) {
  return x+y;
}

1
2
3
4
5

#include <stdio.h>
int x = 2; // Global variable
int adder(int); // Prototype

int main(void) {

 9
10
11

}

int adder(int y) { // y is local

13

}

Luckily for C, there is no problem with nested scoping. This is because nested functions are not allowed. In other words, you cannot define a function inside another function. Furthermore, if we follow ANSI C, then variable declarations have to be at the start of the function. As such, if we follow ANSI C, then we cannot have a variable declaration within a block. This makes the scoping rule very simple.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int f(int);

int main(void) {
  int a;
  :
  return 0;
}

int f(int x) {
  return a + x;
}

Pass-by-Value

When we call a function, there are several operations happening behind the scene.

1. Evaluate the arguments.
2. Copy the arguments to parameters positionally (i.e., 1^st argument to 1^st parameter, 2^nd argument to 2^nd parameter, and so on).
3. Evaluate the function body.
4. Copy the return value back to the caller (if any).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <stdio.h>
#include <math.h>

double sqrt_sum_square(double, double);

int main(void) {
  double a = 10.5, b = 7.8;
  printf("%.2f\n", sqrt_sum_square(3.2, 12/5));
  printf("%.2f\n", sqrt_sum_square(a, a+b));
  return 0;
}

double sqrt_sum_square(double x, double y) {
  double sum_square;  
  sum_square = pow(x,2) + pow(y,2);
  return sqrt(sum_square);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <stdio.h>
void g(int, int);

int main(void) {
  int a = 2, b = 3;

  printf("In main, before: a=%d, b=%d\n", a, b);
  g(a, b);
  printf("In main, after : a=%d, b=%d\n", a, b);    return 0; 
}

void g(int a, int b) {
  printf("In g, before: a=%d, b=%d\n", a, b);
  a = 100 + a;
  b = 200 + b; 
  printf("In g, after : a=%d, b=%d\n", a, b);
}

1
2
3
4

In main, before: a=2, b=3
In g, before: a=2, b=3
In g, after : a=102, b=203
In main, after : a=2, b=3

Consequence of Pass-by-Value

Let's go back to the motivation for learning pointers. Can we use the following function to swap the values in a and b below?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>
void swap(int, int);

int main(void) {
  int a = 2, b = 3;

  printf("In main, before: a=%d, b=%d\n", a, b);
  swap(a, b);
  printf("In main, after : a=%d, b=%d\n", a, b);    return 0; 
}

void swap(int a, int b) {
  int temp = a;
  a = b;
  b = temp;
}

You should get the following output:

1
2

In main, before: a=2, b=3
In main, after : a=2, b=3

What is happening? Why is it that we cannot modify the variable a and b using the function swap? The answer is that pass-by-value copies the value from arguments to parameters. This means that we have two copies of the value 2 (respectively 3).

1. The value in variable a (respectively b), accesible in main.
2. The value in variable a (respectively b), accesible in swap.

Although the variable name is the same, they actually refer to different variables due to scoping. So now, any changes in a (respectively b) inside swap will only affect the local copy. Hence, the value of a (respectively b) in main is unchanged.

The visualisation is shown above. Notice that the changes inside swap does not affect main.

Pass the Reference

The consequence of pass-by-value brings us back to the use of pointers. If we really want to modify the content of variable a (respectively b) in main using the function swap, then we have to allow for indirect access of the variable. This is because direct access is impossible due to the scoping rule.

How do we give the indirect access to the function swap? We have to pass the address of the variable! To do so, the function has to accept a pointer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>
void swap(int*, int*);

int main(void) {
  int a = 2, b = 3;

  printf("In main, before: a=%d, b=%d\n", a, b);
  swap(&a, &b);
  printf("In main, after : a=%d, b=%d\n", a, b);    return 0; 
}

void swap(int *ptr1, int *ptr2) {
  int temp = *ptr1;
  *ptr1 = *ptr2;
  *ptr2 = temp;
}

The box-and-arrow diagram is shown above. Note the difference when a pointer is used.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>
void f(int, int, int);

int main(void) {
  int a = 9, b = -2, c = 5;
  f(a, b, c);
  printf("a = %d, b = %d, c = %d\n", a, b, c);
  return 0;
}

void f(int x, int y, int z) {
  x = 3 + y;
  y = 10 * x;
  z = x + y + z;
  printf("x = %d, y = %d, z = %d\n", x, y, z);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>
void f(int *, int *, int *);

int main(void) {
  int a = 9, b = -2, c = 5;
  f(&a, &b, &c);
  printf("a = %d, b = %d, c = %d\n", a, b, c);
  return 0;
}

void f(int *x, int *y, int *z) {
  *x = 3 + *y;
  *y = 10 * *x;
  *z = *x + *y + *z;
  printf("*x = %d, *y = %d, *z = %d\n", *x, *y, *z);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>
void f(int *, int *, int *);

int main(void) {
  int a = 9, b = -2, c = 5;
  f(&a, &b, &c);
  printf("a = %d, b = %d, c = %d\n", a, b, c);
  return 0;
}

void f(int *x, int *y, int *z) {
  *x = 3 + *y;
  *y = 10 * *x;
  *z = *x + *y + *z;
  printf("x = %d, y = %d, z = %d\n", x, y, z);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include <stdio.h>
void f(int *, int *, int *);

int main(void) {
  int a = 9, b = -2, c = 5;
  f(&a, &b, &c);
  printf("a = %d, b = %d, c = %d\n", a, b, c);
  return 0;
}

void f(int *x, int *y, int *z) {
  *x = 3 + *y;
  *y = 10 * *x;
  *z = *x + *y + *z;
  printf("x = %p, y = %p, z = %p\n", x, y, z);
}