What You Will Learn

• The difference between actual arguments and formal parameters
• Why a function cannot change the caller’s variable by default
• Why C has only call by value, and how pointers simulate call by reference
• Why a swap function written with plain ints fails
• How arrays and structures behave when passed to functions
• How to answer common interview questions on this topic

Prerequisites

To understand call by value in C you should know how to write a function, declare variables and use the address-of and dereference operators. The earlier lectures of this chapter on pointer basics and arrays help, but nothing beyond a standard C compiler is needed for this free C tutorial.

What Call by Value in C Means

When you call bump(hits), the value stored in hits is evaluated and copied into a brand-new variable that belongs to bump. The value you write in the call is the actual argument. The variable declared in the function header is the formal parameter. They hold the same number at the start, but they are two separate objects at two different addresses.

Because the callee only has a copy, any change it makes disappears when the function returns. That is a feature, not a flaw: a function can use its parameters as scratch variables without worrying about damaging the caller’s data.

Call by Value in C vs Call by Reference

Demo: Call by Value in C in Action

This program shows three things: a copy that changes while the original stays the same, a swap that does nothing, and a short preview of the pointer-based fix. Save it as ep_call_by_value.c.

#include <stdio.h>

/* Gets a COPY of the caller's value. */
static void bump(int count, const int *caller_addr)
{
    count = count + 1;
    printf("inside bump : count = %d\n", count);
    printf("inside bump : same object as caller's variable? %s\n",
           (&count == caller_addr) ? "yes" : "no");
}

/* Classic mistake: swaps two private copies. */
static void swap_bad(int a, int b)
{
    int t = a;
    a = b;
    b = t;
    printf("inside swap_bad : a = %d, b = %d\n", a, b);
}

/* Peek ahead: handing over addresses lets the callee reach the originals. */
static void swap_ok(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

int main(void)
{
    int hits = 5;
    int x = 3, y = 9;

    bump(hits, &hits);
    printf("back in main : hits = %d\n\n", hits);

    swap_bad(x, y);
    printf("back in main : x = %d, y = %d\n\n", x, y);

    swap_ok(&x, &y);
    printf("after swap_ok : x = %d, y = %d\n", x, y);
    return 0;
}

gcc -std=c11 -Wall -Wextra -pedantic -o ep_call_by_value ep_call_by_value.c
./ep_call_by_value

Expected output:

inside bump : count = 6
inside bump : same object as caller's variable? no
back in main : hits = 5

inside swap_bad : a = 9, b = 3
back in main : x = 3, y = 9

after swap_ok : x = 9, y = 3

Reading the output line by line

• count = 6, hits = 5: the function incremented its own copy only.
• “same object … no”: comparing &count with the caller’s &hits proves they are two different objects.
• swap_bad shows a = 9, b = 3: inside the function the swap really happened, but on copies. Back in main, x and y are unchanged.
• swap_ok works: it receives the addresses of x and y, so *a and *b are the original variables themselves.

Arrays and Structures as Arguments

Arrays behave differently from plain ints, and the earlier lectures explain why. When you pass an array name, the array decays to a pointer to its first element, and that pointer is copied. The elements themselves are not copied. As a result, a function can modify the caller’s array through the pointer. This is exactly what happened when we passed a row such as readings[i] in the 2D array lectures: the function saw the original row, not a copy.

Structures are different again. A struct passed by value is copied in full, so a large struct costs stack space and time. In embedded C programming the usual habit is to pass a const pointer to the struct for read-only access, and a plain pointer when the function must update it.

Where This Shows Up in Embedded Systems

• A function such as uart_set_baud(int baud) can compute with its copy freely; the caller’s variable is safe. That is call by value in C protecting your data.
• A driver that must return several results, for example a value and a status, takes pointers as output parameters.
• Interrupt handlers and callbacks often receive a pointer to a context structure, because copying the whole structure inside an ISR would be slow.
• Large configuration tables are passed as const pointers so that they stay in flash and are never duplicated on a small stack.

Common Mistakes With Call by Value in C

Best Practices for Call by Value in C

• Pass small values (ints, enums, flags) by value. It is simple and safe.
• Pass an address when the function must modify the caller’s data, and document which parameters are outputs.
• Pass const pointers for large read-only data.
• Performance: copying a 4-byte int is free; copying a 200-byte struct on every call is not.
• Safety: check pointer parameters for NULL before dereferencing them if callers are not under your control.

Summary and Key Takeaways

• Call by value in C means every argument is passed as a copy into the parameter.
• Changes to a parameter do not affect the caller’s variable.
• To modify the caller’s data, pass its address and dereference inside the function.
• Arrays decay to a pointer, so their elements can be changed by the callee.
• Large structs are better passed by const pointer than by value.

Quiz: Pointers and Arrays Checkpoint

Ten questions on the last five lectures. Think first, then open the answer. Assume a 4-byte int.

1. int a[3][4] starts at address 0x1000. What is the value of a + 1?

   • A. 0x1004
   • B. 0x1010
   • C. 0x1001
   • D. 0x100C
   Show answer

   B. a points to rows of 16 bytes, so a + 1 is 0x1000 + 16 = 0x1010.

2. In an expression, what is the type of *(a + 2) for int a[3][4]?

   • A. int
   • B. int *
   • C. int (*)[4]
   • D. int **
   Show answer

   B. *(a + 2) is row 2, an array of 4 ints, which decays to int *.

3. Which declaration makes p a pointer to an array of 5 ints?

   • A. int *p[5];
   • B. int (*p)[5];
   • C. int **p[5];
   • D. int p[5]*;
   Show answer

   B. The parentheses bind the star to p first. A declares an array of 5 pointers.

4. What does int *q[5]; declare?

   • A. A pointer to 5 ints
   • B. An array of 5 pointers to int
   • C. A pointer to a pointer
   • D. A syntax error
   Show answer

   B. The subscript binds tighter than the star, so q is an array of 5 int pointers.

5. With int m[3][4] = {{10,11,12,13},{20,21,22,23},{30,31,32,33}}, what is *(*(m + 2) + 1)?

   • A. 21
   • B. 32
   • C. 31
   • D. 23
   Show answer

   C. Row 2 is {30,31,32,33} and column 1 is 31.

6. For int cube[2][3][4], what is sizeof cube[1]?

   • A. 96
   • B. 48
   • C. 16
   • D. 12
   Show answer

   B. One element of cube is a 3 by 4 block: 3 x 4 x 4 bytes = 48.

7. What is the byte offset of cube[1][2][3] from the start of cube?

   • A. 92
   • B. 88
   • C. 23
   • D. 96
   Show answer

   A. Index = (1 x 3 + 2) x 4 + 3 = 23, and 23 x 4 = 92.

8. What does this print? void f(int n) { n = n * 2; } … int v = 7; f(v); printf(“%d”, v);

   • A. 14
   • B. 0
   • C. 7
   • D. Undefined
   Show answer

   C. f changes its own copy, so v is still 7.

9. Which parameter type accepts int a[2][3][4] passed as just a?

   • A. int ***p
   • B. int (*p)[3][4]
   • C. int **p
   • D. int *p
   Show answer

   B. The array name decays to a pointer to a 3 by 4 block. A 3D array is never an int ***.

10. With int (*p)[4] = m; (m as in question 5) and then p++, what is p[0][0]?

    • A. 10
    • B. 11
    • C. 20
    • D. 30
    Show answer

    C. p++ moves one whole row, so p now points at row 1 and p[0][0] is 20.

Programming Challenges

1. Write int max_in_column(int (*m)[4], size_t rows, size_t col) and test it on a 3 by 4 table. Hint: loop over rows and keep the biggest m[r][col].
2. Print the transpose of a 3 by 4 array using only the pointer form *(*(a+i)+j). Hint: the transpose has 4 rows and 3 columns, so swap the indexes when printing.
3. Store a 2 by 2 by 3 table in a flat buffer and write board_max using the IDX macro from lecture 28. Hint: fix the board index, loop over channels and samples.

Interview Questions on Pointers, Arrays and Functions

Frequently Asked Questions