C Programming Notes

 

User-Defined Functions in C Programming

In C programming, functions are reusable blocks of code that perform specific tasks. While C provides a set of built-in (library) functions such as printf(), scanf(), and sqrt(), you can create your own functions, known as user-defined functions.

Advantages of User-Defined Functions

  1. Reusability: You can call the function multiple times without rewriting the code.
  2. Modularity: Code is broken into smaller, manageable parts, improving readability.
  3. Debugging: It is easier to test and debug functions independently.
  4. Code Maintainability: Changes can be made to a single function without affecting the entire program.

Structure of a Function

A user-defined function in C consists of three main parts:

  1. Function Declaration (Prototype): Tells the compiler about the function's name, return type, and parameters.
  2. Function Definition: Contains the actual code or logic of the function.
  3. Function Call: Executes the function when required.

Syntax of a Function

return_type function_name(parameter_list)
{
    // Function body
    // Statements
    return value; // Optional for non-void functions
}
  • return_type: Data type of the value returned by the function (e.g., int, float, void).
  • function_name: Name of the function.
  • parameter_list: Input values passed to the function (optional).
  • return: Exits the function and optionally returns a value to the caller.

Example 1: A Simple Function Without Parameters and Return Value

#include <stdio.h>

// Function Declaration
void greet();  

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

// Function Definition
void greet() {
    printf("Hello! Welcome to C programming.\n");
}

Output:

Hello! Welcome to C programming.

Explanation:

  • The greet() function does not take any input parameters and does not return any value (void).
  • It is defined once but can be called multiple times if needed.

Example 2: Function with Parameters and No Return Value

#include <stdio.h>

// Function Declaration
void displaySum(int a, int b);

int main() {
    int x = 5, y = 7;
    // Function Call with Arguments
    displaySum(x, y);
    return 0;
}

// Function Definition
void displaySum(int a, int b) {
    int sum = a + b;
    printf("The sum of %d and %d is %d\n", a, b, sum);
}

Output:

The sum of 5 and 7 is 12

Explanation:

  • The displaySum function takes two parameters a and b of type int.
  • The sum is calculated and displayed inside the function.
  • The function does not return any value.

Example 3: Function with Parameters and Return Value

#include <stdio.h>

// Function Declaration
int multiply(int a, int b);

int main() {
    int num1 = 4, num2 = 5;
    int result;

    // Function Call with Arguments
    result = multiply(num1, num2);

    printf("The product of %d and %d is %d\n", num1, num2, result);
    return 0;
}

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

Output:

The product of 4 and 5 is 20

Explanation:

  • The multiply function takes two integer parameters and returns an integer value (int).
  • The return statement sends the calculated product back to the main() function.

Example 4: Function Without Parameters but With a Return Value

#include <stdio.h>

// Function Declaration
int getNumber();

int main() {
    int number;

    // Function Call
    number = getNumber();

    printf("You entered: %d\n", number);
    return 0;
}

// Function Definition
int getNumber() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    return num;
}

Output (User input: 15):

Enter a number: 15
You entered: 15

Explanation:

  • The getNumber() function does not take any parameters but returns a value (int).
  • It reads user input, then returns the value to the calling function.

Types of Functions in C

There are four main types of user-defined functions:

  1. No arguments and no return value:
    • Example: void greet()
  2. Arguments but no return value:
    • Example: void displaySum(int a, int b)
  3. No arguments but return value:
    • Example: int getNumber()
  4. Arguments and return value:
    • Example: int multiply(int a, int b)

Calling Functions

Functions can be called in two ways:

  1. Call by Value: A copy of the value is passed to the function. Changes made inside the function do not affect the original value.
  2. Call by Reference: A reference (pointer) to the actual variable is passed. Changes made inside the function affect the original value.

Example 5: Call by Value

#include <stdio.h>

void square(int num);

int main() {
    int n = 4;
    square(n);
    printf("Original value of n: %d\n", n);
    return 0;
}

void square(int num) {
    num = num * num;
    printf("Squared value: %d\n", num);
}

Output:

Squared value: 16
Original value of n: 4

Explanation:

  • num is a copy of n. Modifying num inside the function does not affect n.



more advanced concepts and topics that follow after user-defined functions. These include:

  1. Recursion in C
  2. Arrays in C
  3. Pointers in C
  4. Structures in C
  5. File Handling in C

Let's proceed with the next topic:

Recursion in C Programming

Recursion is a technique where a function calls itself in order to solve smaller instances of a problem. A recursive function generally has two parts:

  1. Base Case: A condition that stops the recursion, preventing an infinite loop.
  2. Recursive Case: The part of the function where it calls itself with new parameters.

Basic Syntax of Recursion:

return_type function_name(parameters) {
    if (base_case_condition) {
        // return result
    } else {
        // recursive call
        function_name(new_parameters);
    }
}

Example 1: Factorial Using Recursion

The factorial of a non-negative integer n is the product of all integers from 1 to n. For example, 5! = 5 * 4 * 3 * 2 * 1 = 120.

Factorial Function Using Recursion:

#include <stdio.h>

int factorial(int n);

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

// Recursive Function Definition
int factorial(int n) {
    if (n == 0)  // Base case
        return 1;
    else
        return n * factorial(n - 1);  // Recursive case
}

Output:

Factorial of 5 is 120

Explanation:

  • The function factorial() keeps calling itself with n-1 until it reaches the base case where n == 0.
  • The result is returned and multiplied as the recursion "unwinds."

Example 2: Fibonacci Sequence Using Recursion

The Fibonacci sequence is a series where each number is the sum of the two preceding ones. The sequence starts with 0 and 1.

Fibonacci Function Using Recursion:

#include <stdio.h>

int fibonacci(int n);

int main() {
    int num = 6;
    printf("Fibonacci of %d is %d\n", num, fibonacci(num));
    return 0;
}

// Recursive Function Definition
int fibonacci(int n) {
    if (n == 0)  // Base case
        return 0;
    else if (n == 1)  // Base case
        return 1;
    else
        return fibonacci(n - 1) + fibonacci(n - 2);  // Recursive case
}

Output:

Fibonacci of 6 is 8

Explanation:

  • The function fibonacci() calls itself twice: once with n-1 and once with n-2, summing the results.
  • The base cases handle n == 0 and n == 1.

Advantages of Recursion:

  1. Simplicity: Recursive solutions are often simpler and easier to understand, especially for problems like tree traversal, factorials, Fibonacci sequences, etc.
  2. Code Clarity: Reduces the need for loops and makes the code more readable in some cases.

Disadvantages of Recursion:

  1. Memory Usage: Each recursive call uses stack memory, and deep recursion can lead to stack overflow.
  2. Efficiency: Recursive functions may be slower due to repeated calculations, especially in problems like the Fibonacci sequence.

Tail Recursion

In some cases, recursion can be optimized using tail recursion, where the recursive call is the last operation in the function. This allows compilers to optimize memory usage by reusing the stack frame.

Next Steps

Once you understand recursion, you can explore other advanced concepts in C such as:

  • Arrays: An array is a collection of similar elements stored in contiguous memory locations. You will learn how to declare, initialize, and manipulate arrays.
  • Pointers: Pointers in C allow you to store memory addresses and work directly with memory, giving you greater control over your data.
  • Structures: Structures allow you to group different data types together, which is useful for organizing complex data.
  • File Handling: Learn how to read from and write to files in C, which is essential for many applications that require persistent storage.


Comments

Post a Comment

Popular posts from this blog

Programming Notes by Atul Kalukhe

Arrays in C Programming Introduction to Python Programming Circle Part 1 Set A Set B Sorting Algorithm for all programming languages Bubble Sort Selection Sort Insertion Sort: Merge Sort: Quick Sort: Radix Sort: Bucket Sort: Heap Sort JAVA Notes User-Defined Functions in Java Java Type Casting For 20 and 21 December (Java Batch) Swing Exception Handling in Java 23 Jan Java Prog 1 23 Jan Java Prog 2 Python Notes Numpy Library Pandas library 20 dec Example Python MCQ Test (25 Marks) The Pandas library Lecture 1 What is tkinter? Pygame Library Bouncing Ball Explanation Catch the Falling Object Game Explanation C Programming Notes C Prog Notes triangle patterns using numbers in C 20 Dec Example in C C Prog MCQ Test (25 Marks) 23 Jan C Prog 1 SS 23 Jan C Prog 2 SS DS Using CPP Data Structures Using C++ Sorting Algorithms: Bubble Sort and Selection Sort with C++ Implementation Python Notes (Vrushali's Batch) Introduction to Python Data structures in Python Math Library in Python 23 Jan P...
Read more