Important Truth: C Has Only Call by Value

Before we begin, one key point:

Then why do many books say “Call by Reference” in C? Because we can pass the address of a variable (using pointers), and that allows the function to modify the original variable. This behaves like Call by Reference, so people use that phrase informally.

Call by Value in C – Copy Only

With Call by Value:

• The function receives a copy of the variable’s value.
• Any changes inside the function affect only the copy, not the original.

Example: Simple Increment (Call by Value)

#include <stdio.h>

void increment(int x) {
    x = x + 1;
    printf("Inside increment: x = %d\\n", x);
}

int main() {
    int a = 5;
    printf("Before call: a = %d\\n", a);
    increment(a);
    printf("After call:  a = %d\\n", a);
    return 0;
}

Output (typical):

Before call: a = 5
Inside increment: x = 6
After call:  a = 5

Inside the function, x becomes 6, but a in main() is still 5, because only a copy was modified.

Classic Problem: swap() That Doesn’t Work (Call by Value)

This is the famous beginner bug:

#include <stdio.h>

void swap(int x, int y) {
    int temp = x;
    x = y;
    y = temp;
}

int main() {
    int a = 10, b = 20;
    printf("Before swap: a = %d, b = %d\\n", a, b);
    swap(a, b);
    printf("After swap:  a = %d, b = %d\\n", a, b);
    return 0;
}

Output (surprise for beginners):

Before swap: a = 10, b = 20
After swap:  a = 10, b = 20

Using Pointers to Simulate Call by Reference

To modify the original variables in a function, we must give the function access to their addresses. In C, addresses are stored in pointers.

Quick pointer refresher

• & → address-of operator (gives the address of a variable).
• * → used in two ways:
  • In declaration: int *p; means “pointer to int”.
  • In expression: *p means “value at the address stored in p”.

swap() Using Pointers – Call by Reference Style

Let’s fix the swap example using pointers:

#include <stdio.h>

void swap(int *x, int *y) {
    int temp = *x;   // temp = value at address x
    *x = *y;         // value at x = value at y
    *y = temp;       // value at y = temp
}

int main() {
    int a = 10, b = 20;
    printf("Before swap: a = %d, b = %d\\n", a, b);

    swap(&a, &b);   // pass addresses of a and b

    printf("After swap:  a = %d, b = %d\\n", a, b);
    return 0;
}

Output:

Before swap: a = 10, b = 20
After swap:  a = 20, b = 10

Now it works. Why?

• We pass &a and &b (addresses) to the function.
• Inside swap, x and y are pointers to those addresses.
• *x means “the variable at address x” → effectively a.
• *y means “the variable at address y” → effectively b.

Pointer Example: Increment Original Variable

Here is another simple example showing Call by Value vs pointer-based Call by Reference style.

void incValue(int x) {
    x = x + 1;
}

void incRef(int *p) {
    *p = *p + 1;
}

#include <stdio.h>

void incValue(int x) {
    x = x + 1;
}

void incRef(int *p) {
    *p = *p + 1;
}

int main() {
    int a = 5, b = 5;

    incValue(a);   // a stays 5
    incRef(&b);    // b becomes 6

    printf("a = %d (after incValue)\\n", a);
    printf("b = %d (after incRef)\\n", b);

    return 0;
}

Arrays & Functions – Naturally Reference-like

When you pass an array to a function, it already behaves in a reference-like way because the array name decays to a pointer.

Example: Double All Elements in an Array

#include <stdio.h>

void doubleArray(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        a[i] = a[i] * 2;
    }
}

int main() {
    int marks[] = {10, 20, 30};
    int n = 3, i;

    doubleArray(marks, n);   // no & needed

    for (i = 0; i < n; i++) {
        printf("%d ", marks[i]);
    }
    printf("\\n");
    return 0;
}

Output: 20 40 60 The original array values are changed, because inside doubleArray, a acts as a pointer to the original array.

Comparison Table – Call by Value vs Pointer-based Reference Style

Common Mistakes with Call by Value & Pointers

• Expecting normal parameters to change originals: Forgetting that int x is a copy, not the original.
• Forgetting & in function call: Writing swap(a, b) instead of swap(&a, &b) when using pointer parameters.
• Forgetting * when assigning: Writing p = 10; instead of *p = 10; (which changes the pointed value).
• Uninitialized pointers: Using a pointer without assigning it a valid address causes crashes or undefined behaviour.
• Confusing address & value: Printing p vs *p without understanding which is needed.

Learning Checklist (For Tamil Learners)

• I understand that C uses Call by Value for all arguments.
• I can explain why swap(int x, int y) does not change caller variables.
• I can write swap(int *x, int *y) and call it correctly using &.
• I know when to use normal parameters vs pointer parameters.
• I can trace simple pointer code and predict the output.

Suggested Featured Image Prompt

Use this prompt in your AI image generator for the TamilTechnicians.com thumbnail:

“Flat modern 16:9 illustration on a light background. On the left, a small diagram shows `main()` calling `swap(a, b)` with labels ‘Call by Value – copies only’, and the values 10 and 20 in two separate boxes that stay unchanged. On the right, another diagram shows `main()` calling `swap(&a, &b)` with labels ‘Pointer style – address passed’, and two boxes for `a` and `b` whose values 10 and 20 are crossed and swapped to 20 and 10. In the center bottom, a simple memory diagram shows a pointer `p` storing an address (an arrow pointing to a variable box). A South Indian / Tamil technician character stands near the diagrams holding a pointer stick, with small text labels ‘& = address’, ‘* = value at address’. At the top, bold title text: ‘Call by Value vs Call by Reference’ and smaller subtitle: ‘Simple Pointer Examples in C | Tamil Technicians’. Clean vector style, minimal colors, educational and high quality.”