Lesson 11.5. Pointers as function argument in C

In C, there are two methods to pass variables as parameters in a function:

• call by value
• call by reference (or pointer)

Call by value

This is the "classic" technique presented in lesson 8.1 on functions. With this approach, the transmitted variable is copied into the local variable of the the function. Consider the following function:

void fct(int arg) {
  // Display the pointer address of the argument
  printf ("Adsress of arg = %p\n", &arg);
}

// Create a variable named var and display its address
int var=28;
printf ("Addresse of var = %p\n", &var);

// Call the function
fct(var);

When we run this program, we see that the variable var does not have the same address as the variable arg, local to the function. So there are two distinct variables at two different addresses. Their only link is when the function is called: the value of var is copied into arg. This is the reason why we talk about "Call by value". The function fct() cannot modify the variable var.

Call by reference

The second approach is to pass the address of the variable to the function (instead its value). By doing so, the function can modify the content of the variable, even if it is local to another function. Consider the following two functions:

void value(int arg) { arg++; }

void reference(int *arg) { (*arg)++; }

Now let's analyze the following code:

int var1=5,var2=5;

// Call by value
value(var1);
// Display 5: var1 is not modified by the function
printf ("Value => var1 = %d\n", var1);

// Call by reference
reference(&var2);
// Display 6: var2 is modified by the function
printf ("Reference => var2 = %d\n", var2);

When passing by value, the value() function cannot change the content of the variable (var1). On the other hand, when passing by reference, the function variable() can modify the content of the arguments (var2): As it is the address that is passed to the function, the function can modify the content of the variable.

Value     => var1 = 5
Reference => var2 = 6

This technique is used, for example, to overcome the limit on the number of parameters that can be returned by a function with return (i.e. 1). This mechanism is used in the scanf() function so that the variable can be modified by the function.

scanf("%d", &val);
            ^
            Call by reference

Exercise

Exercise 1

Write a swap() function that swaps the contents of two variables::

// Swap the contents of a and b
void swap(int *a, int *b);

Here is the expected output:

Before: x=7 y=8
After : x=8 y=7

#include <stdio.h> // Swap the contents of a and b void swap(int *a, int *b); int main(void) { int x=7,y=8; // Display the variables before swapping printf ("Before: x=%d y=%d\n", x, y); // Swap x and y swap (&x, &y); // Display the variables before swapping printf ("After : x=%d y=%d\n", x, y); return 0; } // Swap the contents of a and b void swap(int *a, int *b) { // COMPLETE HERE

Exercise 2

Write a function percent() that receives as parameter val, a float called per value.

• If val is greater than 100, 100 is assigned to the variable pointed to by arg, the function returns 1 ;
• If val is less than 0, 0 is assigned to the variable pointed by val, the function returns -1 ;
• Otherwise, nothing is modified, the function returns 0

After calling the function, the variable passed in parameter must be between 0 and 100. Here are some examples :

Enter a percentage value: 12.5
12.50% is valid

Enter a percentage value: 156.78
It's too big, I replaced it with 100.00%.

#include <stdio.h> // Prototype of the percent() function // COMPLETE HERE // Main program int main(void) { float pc; printf("Enter a percentage value: "); scanf ("%f", &pc); // Appel de la fonction switch (percent(&pc)) { case 1 : printf ("It's too big, I replaced it with %.2f%%\n", pc); break; case -1 : printf ("It's too small, I replaced it with %.2f%%\n", pc); break; case 0 : printf ("%.2f%% is valid\n", pc); } return 0; } // Implémentation of the percent() function // COMPLETE HERE

Exercise 3

The main() function wait for two parameters:

int main(int argc, char *argv[]) 

• The first one is a pass by value, it represents the number of arguments received when the application is launched.
• The second is a called by reference, it contains an array of pointers to strings (the arguments of the command).

Under Linux, when you type the file listing command ln -a -s in a terminal, you pass the arguments -a and -s to a main() function that was programmed in C.

> ls -a -l
total 20
drwxr-xr-x 1 runner runner   20 Oct 30 16:27 .
drwxr-xr-x 1 runner runner 4096 Oct 30 16:23 ..
-rwxr-xr-x 1 runner runner 8392 Oct 30 16:27 main
-rw-r--r-- 1 runner runner  515 Oct 30 16:27 main.c

Write a program that displays the number and contents of the arguments of the function main():

> ./main
1 argument(s) detected
argv[0] = ./main

> ./main -f test.txt
3 argument(s) detected
argv[0] = ./main
argv[1] = -f
argv[2] = test.txt

#include <stdio.h> int main(int argc, char *argv[]) { // Display the number of arguments // COMPLETE HERE // Display each argument // COMPLETE HERE return 0; }

Exercise 4

Write a function that calculates the roots of a second degree polynomial and returns the discriminant:

• If the discriminant is negative, zero will be assigned to the roots.
• If the discriminant is zero, the two roots will be equal.

double roots(double a, double b, double c, double * r1, double * r2);

Write a main program that asks the user to enter the coefficients of the polynomial before displaying its roots:

Enter the coefficient a : 2.5
Enter the coefficient b : 4.6
Enter the coefficient c : 18.7
 -> Complex roots

Enter the coefficient a : 1
Enter the coefficient b : 4
Enter the coefficient c : 4
 -> Two identical roots: x1 = x2 =-2.00

Enter the coefficient a : 1.4
Enter the coefficient b : 18.5
Enter the coefficient c : 2
 -> Two roots: x1=-0.11 and x2=-13.11

#include <stdio.h> #include <math.h> // Calculate the roots of a 2nd degree polynomial double roots (double a, double b, double c, double * r1, double * r2); int main(void) { // Coefficients of the polynomial double a, b, c; // Discriminant and roots double discriminant, x1, x2; // Ask for the coefficients printf ("Enter the coefficient a : "); scanf ("%lf", &a); printf ("Enter the coefficient b : "); scanf ("%lf", &b); printf ("Enter the coefficient c : "); scanf ("%lf", &c); // Calculate the roots of the polynomial // COMPLETE HERE // Negative Discriminant if (discriminant<0) { printf (" -> Complexe roots\n"); } // Null Discriminant if (discriminant==0) { printf (" -> Two identical roots: x1 = x2 = %.2lf\n", x1); } // Positive Discriminant if (discriminant>0) { printf (" -> Two distincts roots: x1=%.2lf et x2=%.2lf\n", x1, x2); } return 0; } // Calculate the roots of a 2nd degree polynomial double roots (double a, double b, double c, double * r1, double * r2) { // COMPLETE HERE }

Quiz

This function accepts what type of parameter?

void fct(int v);

---

This function accepts what type of parameter?

void fct(int *v);

---

From a purely syntactical point of view, what types of variables can be passed to the following function?

void uppercase(char *arg);

---

What does the following code display?

void addTwo(int i) { i=i+2; }

int main(void) {
  int var=5;
  addTwo(var);
  printf ("var = %d", var);
}

---

What does the following code display?

void addTwo(int *i) { *i=*i+2; }

int main(void) {
  int var=5;
  addTwo(&var);
  printf ("var = %d", var);
}

---

See also

• Learn C programming
• Lesson 1.1. History of C programming language
• Lesson 1.2. First program
• Lesson 1.3. Compilation
• Lesson 1.4. Preprocessor directives
• Lesson 1.5. Which compiler to choose?
• Lesson 1.6. Flowchart
• Lesson 2.1. Types and variables
• Lesson 2.2. Integers
• Lesson 2.3. Floating point numbers
• Lesson 2.4. Characters
• Lesson 2.5. Variables initialization
• Lesson 2.6. Ariane flight 501
• Lesson 3.1. Arithmetic operators
• Lesson 3.2. modulo
• Lesson 3.3. Operators and types
• Lesson 3.4. Type casting
• Lesson 3.5. Bitwise operators
• Lesson 3.6. Bitwise operators details
• Lesson 3.7. Shifting operators
• Lesson 3.8. Assignment operators
• Lesson 3.9. Increment and decrement operators
• Lesson 3.10. Comparison operators
• Lesson 3.11. Logical operators
• Lesson 3.12. Operator precedence
• Lesson 4.1. printf
• Lesson 4.2. scanf
• Lesson 4.3. putchar
• Lesson 5.1. Conditional branching (if...else)
• Lesson 5.2. Nested if and indentation
• Lesson 5.3. Checking intervals
• Lesson 5.4. Ternary Operator ?:
• Lesson 5.5. switch..case statement
• Lesson 5.6. Break keyword in switch..case
• Lesson 6.1. do..while loop in C
• Lesson 6.2. While loop in C
• Lesson 6.3. For loop in C
• Lesson 6.4. How to choose the right loop in C ?
• Lesson 6.5. Exercices on loops in C
• Lesson 7.1. Bit masking
• Lesson 7.2. Bit masking, how to clear a bit in C?
• Lesson 7.3. Bit masking, how to set a bit in C?
• Lesson 7.4. Bit masking, how to toggle a bit in C?
• Lesson 7.5. Bit masking, how to check a single bit in C?
• Lesson 7.6. Overview of bit masking
• Lesson 8.1. Basic syntax of C functions
• Lesson 8.2. Calling C functions
• Lesson 8.3. Void keyword
• Lesson 8.4. Return keyword
• Lesson 8.5. Variable scope
• Lesson 8.6. Global variables
• Lesson 8.7. Static variables
• Lesson 8.8. Random numbers in C
• Lesson 8.9. Mathematical functions in C
• Lesson 9.1. Syntax of C arrays
• Lesson 9.2. Array initialization
• Lesson 9.3. Multidimensional arrays
• Lesson 9.4. How C arrays are stored in memory?
• Lesson 9.5. Arrays and functions
• Lesson 9.6. Exercises on C arrays
• Lesson 10.1. Strings in C
• Lesson 10.2. Null terminated string
• Lesson 10.3. The string.h library
• Lesson 10.4. String and functions
• Lesson 11.1. Introduction to pointers in C
• Lesson 11.2. Syntax of C pointers
• Lesson 11.3. Dynamic memory allocation
• Lesson 11.4. Incrementing pointers
• Lesson 12.1. Introduction to structures in C
• Lesson 12.2. Properties of structures in C
• Lesson 12.3. Structures and pointers
• Lesson 12.4. Structures and functions
• Lesson 13.1. Recursive functions in C
• Lesson 13.2. Depth of recursive functions
• Lesson 13.2. Mutual recursion
• Lesson 14.1. Additional exercises

---