NBC 103 • Unit 215 min read★ High Exam Frequency

Modular Programming & User-Defined Functions (UDF)

Q: What happens if you call a function before its declaration in C?

In older C90 standards, the compiler assumes an implicit declaration with return type 'int'. If the actual definition returns a different type (like float), a type mismatch error or undefined behavior occurs. C99 and newer make this a compilation error. (Examiner Tip: Always supply prototypes before invoking functions.)

Q: Can a C function return multiple values directly?

No. The return statement can return at most one value. However, multiple values can be returned indirectly by passing pointer addresses (Call by Reference simulation) or by packing values into a struct. (Examiner Tip: Pointer parameters allow functions to modify multiple caller variables.)

Unit 2: Control Statements, Loops & Modular Functions • Problem Solving Using C

👨‍🏫 Professor's Mental Model: The Corporate Delegation Hierarchy & Specialized Contractors

Agar ek hi insan company ka sabhi kaam—marketing, accounts, software, delivery—karega toh sab mess ho jayega (Monolithic code)! Isliye CEO (main function) alag-alag specialized departments (User-Defined Functions) banata hai: Accounts team ko data bhejta hai aur wo balance calculate karke wapas bhejti hai. Code chota, clean, re-usable aur bina kisi confusion ke run hota hai!

Academic Lecture Notes & Solved Study Pages

Unit 2 • Core Concepts, Step-by-Step Proofs & Notebook Solutions

4 Notebook Pages

NOTEBOOK PAGE 1 OF 4• Lecture Study Sheet

1. The Philosophy of Modular Programming & Top-Down Design

Modular programming divides a massive software system into discrete, self-contained sub-programs termed functions:

Code Reusability: Write once, invoke thousands of times across the application.

Isolation & Easier Debugging: Logic errors can be tracked down to a specific 10-line function rather than a 2,000-line monolithic script.

Collaborative Team Development: Multiple engineers can develop independent modules simultaneously.

Top-Down Design: Breaking complex problems into manageable functional abstractions.

NOTEBOOK PAGE 2 OF 4• Lecture Study Sheet

2. The 3 Essential Pillars of Function Lifecycle

Every C function requires 3 distinct lifecycle steps:

1. Function Prototype / Declaration: Notifies compiler of function name, return type, and argument list before main() calls it. Syntax: `return_type function_name(param1_type, param2_type);` Example: `int calculate_gcd(int, int);`

2. Function Call / Invocation: Executes the function, passing actual arguments. Syntax: `result = calculate_gcd(num1, num2);`

3. Function Definition: The actual executable implementation containing the header and body enclosed in braces `{}`. Syntax: `return_type function_name(type param1, type param2) { // Local statements return value; }`

NOTEBOOK PAGE 3 OF 4• Lecture Study Sheet

3. Actual Parameters vs Formal Parameters

Actual Parameters (Arguments):

The concrete values, variables, or expressions passed to the function inside the call statement: `swap(a, b);`.

Formal Parameters (Parameters):

The temporary local variables declared in the function definition header that receive incoming copies of values: `void swap(int x, int y)`.

Formal parameters are allocated inside the function's stack frame and destroyed upon return.

NOTEBOOK PAGE 4 OF 4• Lecture Study Sheet

4. The 4 Structural Categories of Functions

Based on argument intake and return capabilities:

1. No arguments & No return value: Pure side-effect (e.g. `void display_banner(void)`). 2. With arguments & No return value: Accepts inputs to print/process (e.g. `void print_square(int n)`). 3. No arguments & With return value: Generates/reads data (e.g. `int get_user_pin(void)`). 4. With arguments & With return value: Pure computational mathematical function (e.g. `double power(double base, int exp)`).

The 4 Categories of User-Defined Functions Matrix

Category	Prototype Example	Caller Invocation	Typical Real-World Use Case
1. No args, No return	void showMenu(void);	showMenu();	Displaying static menus or application banners
2. With args, No return	void logMessage(char msg[]);	logMessage("Connected");	Writing status messages to screen or file
3. No args, With return	int getSystemStatus(void);	status = getSystemStatus();	Polling hardware sensors or random number generators
4. With args, With return	double calcInterest(double p, double r, double t);	si = calcInterest(5000, 7.5, 3);	Mathematical transformations, scientific calculations

Interactive Tested Code Example

#include <stdio.h>
#include <stdbool.h>

// 1. Function Prototypes
bool is_prime(int n);
long long compute_power(int base, int exp);

int main(void) {
    int num = 29, base = 2, exp = 8;

    // Function Invocations
    if (is_prime(num))
        printf("%d is a Verified PRIME number.\n", num);
    else
        printf("%d is a COMPOSITE number.\n", num);

    printf("%d raised to power %d = %lld\n", base, exp, compute_power(base, exp));
    return 0;
}

// 2. Function Definitions
bool is_prime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

long long compute_power(int base, int exp) {
    long long result = 1;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

💡 Note:Exemplifies clean modular C architecture: function declarations at top, executive main() coordinator, and decoupled reusable definitions below.

🎯 University Exam Scoring Blueprint

Always write function prototypes before main() in exam answers to demonstrate adherence to standard ANSI C structure.
Highlight the difference between Actual arguments (in caller) and Formal parameters (in definition).
Explain that C functions can return only ONE direct value via the 'return' statement (returning multiple values requires pointers or structs).