Functions and Modular Programming: Scope, Storage Classes, Inline Functions, Recursion and Parameter Passing

Why functions? Meaning of modular programming

A function is a block of code that performs a specific task. Instead of writing one long program, we divide it into smaller parts.

Modular programming means breaking a program into independent modules (functions) so that:

• each module is easier to understand,
• errors are easier to find and fix,
• code can be reused,
• multiple people can work on different parts.

Real-life analogy: A big project is completed faster when divided into small tasks.

Function structure: declaration, definition and call

A function is usually handled in three steps:

1. Declaration (prototype): tells compiler the function name, return type, and parameters.
2. Definition: actual body (logic).
3. Call: use the function.

Why prototype is useful:

• compiler can check argument types
• function can be defined later in the file

Types of functions (library vs user-defined)

• Library functions: already provided (e.g., sqrt() in <cmath>).
• User-defined functions: written by programmer for custom tasks (e.g., maxOfTwo()).

Return type and void functions

• A function can return a value using return.
• If a function does not return any value, its return type is void.

Example:

• int add(int a, int b) returns an integer.
• void printLine() only prints.

Function arguments and parameters

• Parameters: variables in function definition/prototype.
• Arguments: actual values passed during function call.

Example idea:

• int add(int x, int y) → x and y are parameters
• add(10, 20) → 10 and 20 are arguments

Parameter passing: call by value vs call by reference

This is a very common exam question.

Call by value

A copy of actual argument is passed.

• changes inside function do not affect original variable.

Example situation: swap(a, b) will not swap originals if passed by value.

Call by reference

We pass the address/reference of variable.

• changes inside function do affect original variable.

In C++, call by reference is commonly done using reference parameters like int &x.

Default arguments (intro)

A function parameter can have a default value. If the caller does not provide that argument, the default value is used.

Key rule: default arguments should generally be from the rightmost parameters.

Function overloading (intro)

Function overloading means using the same function name with different parameter lists. Example idea:

• area(int side)
• area(int l, int b)

The compiler decides which one to call based on arguments.

Scope of variables (local, global, block)

Scope means the region where a variable is accessible.

• Local scope: declared inside a function; accessible only inside it.
• Block scope: declared inside { } (like inside if, loops).
• Global scope: declared outside all functions; accessible in all functions (but should be used carefully).

Good practice: prefer local variables to reduce bugs.

Storage classes (basics): auto, register, static, extern

Storage class decides lifetime, scope, and sometimes memory location.

• auto: default for local variables (automatic storage).
• register: request to store variable in CPU register (compiler may ignore).
• static:
  • static local variable retains value between function calls.
  • static global has file-level visibility.
• extern: used to refer to a global variable declared in another file.

In Sem 1, you mainly need conceptual meaning + one example statement.

Static local variable: behaviour and use

A static local variable is initialized only once and keeps its value between calls.

Why useful:

• counting function calls
• caching results

Example concept:

• static int count = 0; count++; will continue increasing across calls.

Inline functions: meaning, advantages and limitations

An inline function suggests the compiler to replace the function call with the function code (expansion at call site).

Advantages:

• reduces function call overhead for small functions

Limitations:

• not suitable for large functions (can increase code size)
• compiler may ignore inline request

Important exam line: inline is a request, not a command.

Recursion: concept, base case and stack idea

Recursion is when a function calls itself.

Two must-have parts:

• Base case: stops recursion (otherwise infinite recursion).
• Recursive step: function calls itself with smaller/simpler input.

Stack idea (simple):

• each call is stored on the call stack
• when base case reached, calls return one by one

Recursion vs iteration (comparison)

• Recursion can make code shorter and cleaner for problems like factorial, Fibonacci, tree traversal.
• Iteration (loops) is often more memory-efficient.

Use recursion carefully because deep recursion can cause stack overflow.

Common errors and debugging tips

• Forgetting function prototype before main() (compiler may not know signature).
• Mismatch of return type (e.g., returning value from void function).
• Missing base case in recursion.
• Confusing call by value and call by reference.
• Shadowing: local variable has same name as global variable.

Tip: Write small test cases and print intermediate values.

Mini table/flowchart for exam answers

Call by value vs call by reference

Function workflow

Prototype → Call from main() → Control goes to function → Execute body → return → back to caller

Quick Recap (1-minute revision)

• Functions enable modular programming and reuse.
• Prototype helps compiler check types.
• Parameters vs arguments: definition vs call.
• Call by value passes a copy; call by reference modifies original.
• Scope: local/block/global; storage classes control lifetime/visibility.
• Inline reduces call overhead (for small functions).
• Recursion needs a base case; uses call stack.