Chapter 6: Functions

Introduction to Functions

Functions are a fundamental building block in C programming. They allow you to encapsulate code into reusable blocks, making programs more modular, easier to read, and easier to maintain. Functions help break down complex problems into smaller, manageable tasks. By defining functions, you can write cleaner and more organized code, facilitating debugging and enhancing code reusability.

What is a Function?

A function is a block of code that performs a specific task. It can take inputs (known as arguments or parameters), perform operations on these inputs, and return a result. Functions in C are similar to mathematical functions, where you provide input values and receive an output.

Benefits of Using Functions

• Modularity: Functions break down complex problems into simpler, smaller tasks.
• Reusability: You can reuse functions across different parts of a program or even in different programs.
• Maintainability: Functions make it easier to manage and update code, as changes can be made in one place without affecting other parts of the program.
• Readability: Functions improve the readability of the program by reducing code redundancy and separating concerns.

Defining and Calling Functions

Function Definition

A function definition consists of the function name, return type, parameter list, and the body of the function. The syntax is as follows:

return_type function_name(parameter_list) {
    // function body
}

• return_type: The data type of the value the function returns. If the function does not return a value, the return type is void.
• function_name: The name of the function, which should be descriptive and follow C naming conventions.
• parameter_list: A comma-separated list of parameters the function takes. Each parameter is defined by its data type and name.

Function Declaration

A function declaration (or prototype) tells the compiler about the function’s name, return type, and parameters before the function is used in the program. This is typically done at the beginning of the file or in a header file.

return_type function_name(parameter_list);

Function Call

To execute a function, you need to call it from another function (typically main). A function call consists of the function name followed by parentheses containing any arguments.

function_name(arguments);

Example: Simple Function

Function Definition

Here is a simple example of a function definition that prints a greeting message:

#include <stdio.h>

void greet() {
    printf("Hello, World!\n");
}

Function Call

To call the greet function, you need to declare it and then call it from the main function:

#include <stdio.h>

void greet(); // Function declaration

int main() {
    greet(); // Function call
    return 0;
}

void greet() { // Function definition
    printf("Hello, World!\n");
}

Functions with Parameters

Functions can accept inputs known as parameters to perform tasks with specific data. Parameters allow functions to operate on different data without changing the function itself.

Example: Function with Parameters

This example defines a function that takes a string as a parameter and prints it:

#include <stdio.h>

void displayMessage(char message[]) {
    printf("%s\n", message);
}

int main() {
    displayMessage("Hello, C Programming!");
    return 0;
}

Functions with Return Values

Functions can return values using the return statement. The return value can be used directly or stored in a variable.

Example: Function with Return Value

This example defines a function that takes two integers as parameters and returns their sum:

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3);
    printf("Sum: %d\n", result);
    return 0;
}

Functions with Multiple Parameters

You can pass multiple parameters to a function, allowing it to operate on more than one piece of data.

Example: Function with Multiple Parameters

This example defines a function that multiplies two integers and returns the result:

#include <stdio.h>

int multiply(int a, int b) {
    return a * b;
}

int main() {
    int product = multiply(4, 7);
    printf("Product: %d\n", product);
    return 0;
}

Recursive Functions

A recursive function is one that calls itself. Recursion is useful for problems that can be broken down into smaller, similar problems. Each recursive call should bring the problem closer to a base case to avoid infinite loops.

Example: Recursive Function

This example defines a recursive function to calculate the factorial of a number:

#include <stdio.h>

int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int num = 5;
    printf("Factorial of %d is %d\n", num, factorial(num));
    return 0;
}

Inline Functions

Inline functions are defined with the inline keyword and are typically small functions. The compiler attempts to expand them in place to reduce function call overhead, improving performance.

Example: Inline Function

This example defines an inline function to calculate the square of a number:

#include <stdio.h>

inline int square(int x) {
    return x * x;
}

int main() {
    printf("Square of 5: %d\n", square(5));
    return 0;
}

Practical Examples in C

Here are some practical examples to illustrate the use of functions in C.

Example 1: Finding the Maximum of Two Numbers

This function compares two integers and returns the larger one:

#include <stdio.h>

int max(int a, int b) {
    if (a > b)
        return a;
    else
        return b;
}

int main() {
    int num1 = 10, num2 = 20;
    printf("Maximum: %d\n", max(num1, num2));
    return 0;
}

Example 2: Calculating the Average of an Array

This function calculates the average of the elements in an array:

#include <stdio.h>

float average(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return (float)sum / size;
}

int main() {
    int numbers[] = {2, 4, 6, 8, 10};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    printf("Average: %.2f\n", average(numbers, size));
    return 0;
}

Example 3: Checking Prime Number

This function checks whether a given number is a prime number:

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

bool isPrime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i <= n / 2; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

int main() {
    int num = 29;
    if (isPrime(num)) {
        printf("%d is a prime number.\n", num);
    } else {
        printf("%d is not a prime number.\n", num);
    }
    return 0;
}

Conclusion

Functions are essential for structuring your C programs efficiently. They allow you to encapsulate code into reusable units, making your programs modular, maintainable, and easier to read. By mastering functions, you can solve complex problems more effectively.