Functions

What is a function?

A function groups statements under a name, optionally accepts parameters (inputs) and optionally returns a value (output).

int add(int a, int b) {   /* return type, name, parameters */
    return a + b;         /* body — the work */
}

• Return type — type of value sent back (void if none)
• Name — identifier used to call it
• Parameters — inputs declared in the brackets
• Body — statements inside { }
• return — sends a value back and ends the function

Why functions?

• Reusability — write once, call many times
• Readability — main() becomes a short summary of steps
• Divide and conquer — break a big problem into small tasks
• Easier testing / debugging — check one small function at a time
• Less duplication — fix a bug in one place, not ten
• Teamwork — different people can write different functions

Types of functions

C functions fall into two broad groups:

User-defined functions are further grouped by arguments and return value:

Types of calling a user-defined function

Two things are commonly meant by “types of calling”: the four argument/return combinations above, and the mechanism used to pass data.

(a) Call by value — a copy is sent; the original is unchanged:

void change(int x) {
    x = 100;          /* only the copy changes */
}

int n = 5;
change(n);              /* n is still 5 */

(b) Call by reference (via pointers) — an address is sent; the original changes:

void change(int *p) {
    *p = 100;         /* writes through the address */
}

int n = 5;
change(&n);             /* n becomes 100 */

Function prototype (declaration)

A prototype tells the compiler the function’s name, return type, and parameter types before it is used, so calls can be checked.

int    add(int a, int b);   /* prototype — ends with ; */
void   greet(void);            /* takes no arguments */
double area(double r);        /* returns a double */
int    add(int, int);         /* names are optional */

Definition, call, and return

return_type name(parameter list) {
    /* local declarations */
    /* statements */
    return value;   /* omit for void */
}

• Actual arguments — values you pass at the call: add(2, 3)
• Formal parameters — names in the definition: int a, int b
• return — ends the function immediately and sends a value back
• void functions may use a bare return; to exit early

Local vs global — scope basics

• Local variables — declared inside a function; exist only during the call
• Parameters — behave like locals initialized from the arguments
• Global variables — declared outside all functions; visible everywhere (use sparingly)
• Two functions may use the same local name without any clash

How a call works — the stack frame

Each call pushes a frame holding the parameters, local variables, and the return location. When the function returns, its frame is popped — which is why locals do not survive the call.

• Deep call chains and recursion consume stack space
• Large local arrays live in the frame — huge ones can overflow the stack
• Return value travels back to the caller’s expression

Passing arrays, strings, and structs

int findMax(int a[], int n);        /* 1D array + length */
void printMat(int m[][3], int rows); /* 2D: columns must be known */
int countVowels(const char s[]);   /* string ends at '\0' */

• Arrays decay to pointers — the function can modify the caller’s data
• Strings need no length parameter (the '\0' marks the end)
• Structs are copied by value unless you pass struct T *
• Use const on parameters you promise not to modify

Return values — rules and traps

Recursion — a function calling itself

long fact(int n) {
    if (n <= 1)
        return 1;        /* base case — stops recursion */
    return n * fact(n - 1);  /* recursive case */
}

• Every recursion needs a base case and progress toward it
• Each level uses its own stack frame — deep recursion can overflow
• Iteration is often faster; recursion is clearer for trees and divide-and-conquer

Storage & linkage — static, extern, inline

int counter(void) {
    static int count = 0;  /* initialized once; survives calls */
    count++;
    return count;
}

Organising functions across files

• Put prototypes in a header (.h) file
• Put definitions in a source (.c) file
• #include "myheader.h" wherever you call those functions
• Mark file-private helpers static to avoid name clashes

Common mistakes