Functions in C

# CHAPTER 9

Functions in C #

1. Introduction #

2. Learning Objectives #

• Understand why functions are essential for modularity.

• Differentiate between function declaration, definition, and call.

• Pass parameters/arguments to functions.

• Return values from functions.

• Understand local vs. global scope.

3. Why Use Functions? #

• Reusability: Write once, use many times.

• Modularity: Break a large, complex program into small, manageable chunks.

• Maintainability: Easier to debug isolated blocks of code.

4. Creating a Function #

1. 1. Declaration (Prototype): Tells the compiler the function exists (name, return type, parameters).

1. 2. Definition: The actual code the function executes.

1. 3. Call: When you use the function in your program.

#include <stdio.h>

// 1. Function Declaration (Prototype)
void sayHello(); 

int main() {
    // 3. Function Call
    sayHello(); 
    sayHello();
    return 0;
}

// 2. Function Definition
void sayHello() {
    printf("Hello there!\n");
}

5. Parameters and Arguments #

#include <stdio.h>

// Function taking a string (character array) and an integer
void greetUser(char name[], int age) {
    printf("Hello %s, you are %d years old.\n", name, age);
}

int main() {
    // Calling with arguments
    greetUser("Alice", 25);
    greetUser("Bob", 30);
    return 0;
}

6. Return Values #

#include <stdio.h>

// 'int' means this function returns an integer
int addNumbers(int a, int b) {
    int sum = a + b;
    return sum;
}

int main() {
    int result = addNumbers(5, 10);
    printf("The sum is: %d\n", result);
    return 0;
}

7. Scope: Local vs Global Variables #

• Local Variables: Declared *inside* a function. They only exist inside that function.

• Global Variables: Declared *outside* all functions. They can be accessed by any function.

#include <stdio.h>

int globalVar = 100; // Global

void myFunction() {
    int localVar = 10; // Local
    printf("Global: %d, Local: %d\n", globalVar, localVar);
}

int main() {
    myFunction();
    // printf("%d", localVar); // ERROR! localVar does not exist here.
    return 0;
}

8. Introduction to Recursion #

void count(int n) {
    if (n == 0) return; // Base case (stopping condition)
    printf("%d ", n);
    count(n - 1); // Function calls itself
}
// Calling count(3) prints: 3 2 1

9. Memory-Level Explanation (The Call Stack) #

Call Stack when addNumbers(5, 10) is called:
+------------------------+
| addNumbers() Frame     |  <- a=5, b=10, sum=15
+------------------------+
| main() Frame           |  <- result=?
+------------------------+

10. Common Mistakes #

• Forgetting the return statement: If a function specifies int return type, failing to return an integer causes undefined behavior.

• Type mismatch: Passing a float into a function that expects an int.

• Calling before declaring: If you define a function *below* main(), you MUST provide a prototype declaration *above* main().

11. Exercises #

1. 1. Write a function float celsiusToFahrenheit(float c) that converts and returns a temperature.

1. 2. Write a function void printStars(int count) that prints a line of asterisks based on the count.

1. 3. Write a program with a global variable, and modify it from inside a function.

12. MCQ Quiz with Answers #

13. Interview Questions #

• Q: Explain the difference between pass-by-value and pass-by-reference. (Note: C only truly supports pass-by-value; we simulate reference with pointers).

• Q: What is the Call Stack and what is a Stack Overflow?

• Q: Why use function prototypes?

14. Summary #

15. Next Chapter Recommendation #