Functions in C

A function in C is a self-contained block of code that performs a specific task and can be called (invoked) from other parts of a program. Functions let you break a large program into smaller, reusable, and testable pieces. C programs are built from functions — every C program has at least one, main(), which is where execution begins. Beyond main(), you can write your own functions to avoid repeating code, to organize logic into named units, and to make programs easier to read, debug, and maintain.

Functions in C fall into two categories: library functions (predefined functions such as printf(), scanf(), strlen(), and sqrt() that come with the C Standard Library and are declared in header files like stdio.h, string.h, and math.h) and user-defined functions (functions that you write yourself to perform tasks specific to your program). This lesson focuses on user-defined functions — how to declare, define, call, and pass data to and from them.

A function's signature consists of its return type, its name, and the types (and optionally names) of its parameters. The return type specifies what kind of value the function sends back to the caller; use void if the function returns nothing.

A function declaration (also called a prototype) tells the compiler the function's name, return type, and parameter types WITHOUT providing the body. It ends with a semicolon: int add(int a, int b);. A function definition provides the actual body of the function — the code that executes when the function is called: int add(int a, int b) { return a + b; }. In small single-file programs you can define a function before main() and skip a separate prototype, but in larger programs, prototypes are placed near the top of the file (or in a header file) so that functions can be called before their full definition appears later in the file, or from other source files entirely.

Without a prototype, if you call a function before the compiler has seen its definition, older compilers assumed an implicit int return type — a dangerous, non-standard behavior that C99 and later standards disallow, producing a compile error instead. Always declare a prototype (or define the function) before it is first called. Prototypes also let the compiler perform type checking on arguments, catching mismatched-type bugs at compile time rather than causing undefined behavior at runtime.

A parameter is the variable listed in the function's definition/declaration (a placeholder). An argument is the actual value supplied when the function is called. In int add(int a, int b), 'a' and 'b' are parameters; in add(5, 3), 5 and 3 are arguments. C requires the number and (compatible) types of arguments to match the parameters, since C does not support default argument values or function overloading the way C++ does — every function call must supply exactly the arguments the prototype demands.

C passes all arguments by value: when you call a function, the function receives a COPY of each argument's value, not the original variable. Any changes the function makes to its parameters have no effect on the caller's original variables. This is why a function like void increment(int x) { x = x + 1; } does not change the variable passed to it — 'x' inside the function is a separate copy in its own stack frame.

The return statement ends a function's execution and optionally sends a value back to the caller. Its type must match (or be convertible to) the function's declared return type. A function declared void must not return a value (a bare return; is allowed to exit early). A function can have multiple return statements along different code paths, but execution stops at whichever one runs first. If a non-void function reaches its closing brace without hitting a return, the returned value is undefined — always ensure every path returns a value.