15. C Error Handling

What we will learn in this post?

• 👉 Error Handling in C
• 👉 Using goto for Exception Handling in C
• 👉 Error Handling During File Operations in C
• 👉 C Program to Handle Divide By Zero and Multiple Exceptions
• 👉 Conclusion!

🛡️ Error Handling in C: Your Guide to Safe Code 🚀

Hey there, code explorer! 👋 Let’s talk about something super important in programming: error handling. Imagine building a house 🏠 without considering what happens when it rains or the wind blows hard. Not a good idea, right? Similarly, in C programming, we need to think about what could go wrong and prepare for it. This is where error handling comes in!

Why Error Handling is a Big Deal 🧐

Error handling is like having a safety net for your program. Without it, your code could:

• Crash unexpectedly: Imagine your program suddenly stopping, like a car hitting a wall! 💥
• Produce incorrect results: Like doing a math problem wrong and getting the wrong answer. 😕
• Leave users confused and frustrated: No one likes a program that doesn’t work as expected! 😠

Robust programming, which is the goal of a good developer, means writing code that is reliable, resilient, and easy to maintain. Error handling is a crucial part of achieving this.

Common Ways to Handle Errors in C 🛠️

C provides a few ways to gracefully deal with errors. Let’s look at some popular techniques:

Return Codes 🚦

• How it works: Many functions in C return a value that signals if the operation was successful or if an error occurred. Typically, 0 indicates success, and a non-zero value indicates an error.

• Example:

  #include <stdio.h>
  
  int divide(int a, int b) {
      if (b == 0) {
          return -1; // Error: Division by zero
      }
      return a / b;
  }
  
  int main() {
      int result = divide(10, 2);
      if (result != -1) {
          printf("Result: %d\n", result); //Output: Result: 5
      } else {
          printf("Error: Division by zero!\n"); // This won't be executed as result is not -1.
      }
  
        result = divide(10, 0);
        if (result != -1) {
           printf("Result: %d\n", result);
         } else {
             printf("Error: Division by zero!\n"); // Output: Error: Division by zero!
          }
  
      return 0;
  }
  

• Pros: Simple to implement, widely used.
• Cons: Can make code look cluttered if many functions return error codes.

The errno Variable ⚠️

• How it works: The errno variable (declared in <errno.h>) is set by many system functions to indicate the specific type of error.

• Example:

  #include <stdio.h>
  #include <errno.h>
  #include <string.h>
  
  int main() {
      FILE *fp = fopen("nonexistent.txt", "r");
      if (fp == NULL) {
          printf("Error opening file: %s\n", strerror(errno)); // Output : Error opening file: No such file or directory
          return 1;
      }
      // ... file operations
      fclose(fp);
      return 0;
  }
  

• Pros: Provides a more detailed description of the error using strerror.
• Cons: errno can be overwritten by subsequent function calls if you don’t check it immediately.

Using assert.h for debugging 🐞

• How it works: assert(condition) stops the program if the given condition is false. It’s mainly used for detecting bugs during development.

• Example:

  #include <stdio.h>
  #include <assert.h>
  
  int calculateArea(int width, int height) {
     assert(width > 0 && height > 0); // If height/width is non-positive it will stop the execution
      return width * height;
  }
  
  int main(){
     int area = calculateArea(5, 10);
     printf("Area of the rectangle is: %d\n", area);
     // area = calculateArea(-5, 10); // This will cause a program stop because assert will return false.
  }
  
  

• Pros: Helps catch errors early in the development process, very helpful during debugging.
• Cons: Not designed for error handling in production code; assert statements are usually removed in release builds.

Custom Error Handling ⚙️

• How it works: You can define your own error codes and functions to manage errors based on your specific needs.

• Example:

  #include <stdio.h>
  #include <stdlib.h>
  
  typedef enum {
     SUCCESS,
     INVALID_INPUT,
     MEMORY_ERROR
  } ErrorCode;
  
  ErrorCode allocateMemory(int **ptr, size_t size){
     if(size <=0){
        return INVALID_INPUT;
     }
     *ptr = malloc(size);
     if(*ptr == NULL){
       return MEMORY_ERROR;
     }
     return SUCCESS;
  }
  
  void handle_error(ErrorCode err){
    switch(err){
      case SUCCESS:
         printf("Memory allocated successfully\n");
         break;
      case INVALID_INPUT:
         printf("Invalid size passed, needs to be a positive number \n");
         break;
      case MEMORY_ERROR:
        printf("Failed to allocate memory, exiting the program.\n");
        exit(1);
    }
  }
  
  int main(){
      int *ptr;
      ErrorCode result;
      result = allocateMemory(&ptr, sizeof(int)*5);
      handle_error(result);
       if(result == SUCCESS){
         *ptr = 10;
       }
       result = allocateMemory(&ptr, 0);
       handle_error(result);
  
       result = allocateMemory(&ptr, sizeof(int)*100000000000);
       handle_error(result);
  
      free(ptr);
    return 0;
  }
  

• Pros: Flexible and tailored to the project’s requirements.
• Cons: Requires more design and implementation work.

A Simple Flowchart for Error Handling 🤔

Let’s visualize the error handling process:

graph LR
    A[🔹 Start] --> B{⚙️ Operation}
    B -- Success --> C[✅ Proceed]
    B -- Error --> D{❌ Handle Error}
    D --> E[📜 Log Error]
    E --> F[🧹 Clean Up Resources]
    F --> G[↩️ Return/Exit]
    C --> H[▶️ Continue Program]
    G --> I[🔚 End]
    H --> I

    class A startNode
    class B decisionNode
    class C processNode
    class D decisionNode
    class E processNode
    class F processNode
    class G returnNode
    class H processNode
    class I returnNode

    classDef startNode fill:#00BFAE,stroke:#00796B,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef processNode fill:#FF6F61,stroke:#D32F2F,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10px;
    classDef decisionNode fill:#FFD54F,stroke:#F57F17,color:#000000,font-size:16px,stroke-dasharray: 5,5;
    classDef returnNode fill:#4CAF50,stroke:#388E3C,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;

Key Takeaways 🎯

• Always check for errors: Don’t assume functions will always succeed.
• Use errno for more detailed error information: It helps to be specific in debugging.
• Handle errors gracefully: Display informative messages instead of crashing.
• Choose the right error handling method: Tailor it to your project’s needs.
• Practice: The more you practice, the better you’ll get at writing robust code!

Resources for further exploration 📚

• GeeksforGeeks: Error Handling in C
• Tutorialspoint: C Error Handling
• Learn C the Hard way: Debugging with assert and assert.h

Remember, error handling is not just an “add-on” – it’s a core part of writing solid, reliable C programs. Keep exploring, keep learning, and happy coding! 😄

Diving into goto for Error Handling in C 🤿

Let’s talk about goto! It’s often a controversial topic in C programming, especially when it comes to handling errors. While goto can sometimes seem like a quick fix, it’s important to understand its quirks, both good and bad. So, let’s break it down!

What’s the Deal with goto? 🤨

goto is a C statement that lets you jump directly to a specific point in your code marked by a label. It’s like a teleportation device for your program’s execution flow. While seemingly powerful, it can also make your code harder to follow if used carelessly. Think of it like this: it’s like having a map with too many shortcuts – sometimes, the direct path is more confusing than the long way around! 🗺️

Using goto for Error Handling 🐞

In C, which doesn’t have built-in exception handling like try-catch in other languages, goto can be used as a basic method to jump to cleanup routines when something goes wrong. This often involves skipping normal execution and immediately releasing allocated memory or closing open files.

Here’s a simplified idea of the process:

graph LR
    A[🔹 Start] --> B{⚙️ Some Operation}
    B -- Success --> C{⚙️ Another Operation}
    C -- Success --> D{⚙️ Yet Another Operation}
    D -- Success --> E[✅ End]
    B -- Error --> F{❌ Error Handling}
    C -- Error --> F
    D -- Error --> F
    F --> E

    class A startNode
    class B decisionNode
    class C decisionNode
    class D decisionNode
    class E returnNode
    class F processNode

    classDef startNode fill:#00BFAE,stroke:#00796B,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef decisionNode fill:#FFD54F,stroke:#F57F17,color:#000000,font-size:16px,stroke-dasharray: 5,5;
    classDef returnNode fill:#4CAF50,stroke:#388E3C,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef processNode fill:#FF6F61,stroke:#D32F2F,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10px;

How It Looks in Code:

#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *file = NULL;
    int *data = NULL;

    // Attempt to open a file
    file = fopen("data.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        goto error; // Jump to error handling if file opening fails
    }

    // Allocate memory
    data = (int *)malloc(10 * sizeof(int));
    if (data == NULL) {
        perror("Error allocating memory");
        goto error; // Jump to error handling if malloc fails
    }
    //... do other stuff


    fclose(file);
    free(data);
    printf("Success!\n");
    return 0;

error:
    if (file != NULL) {
        fclose(file); // Close file if it was opened
    }
    if (data != NULL) {
        free(data);   // Free memory if it was allocated
    }
    printf("An error occurred. Cleanup performed.\n");
    return 1;
}

The Good, the Bad, and the goto 🎭

Let’s get into the nitty-gritty of when goto might be a reasonable choice for error handling, and when you’d better steer clear.

Pros of using goto: ✅

• Simplified Cleanup: When dealing with nested operations, goto can allow you to jump directly to a single cleanup point, avoiding repetitive if checks. This can make your code slightly less verbose in certain cases.
• Centralized Error Handling: You can gather all your cleanup code in one spot, which can make it easier to manage and modify. It helps you keep the code that handles errors separate from the main flow.
• Resource Management: Crucially, it ensures all allocated resources like files and memory are released if a failure occurs, preventing memory leaks. It acts as a primitive form of finally block.

Cons of using goto: ❌

• Spaghetti Code: Unrestrained use of goto can create a jumbled, hard-to-follow control flow. This is where the dreaded “spaghetti code” term originates, making debugging a nightmare. 🍝
• Reduced Readability: Jumps within your code can make it difficult to trace the program’s execution, especially in complex functions. This hurts maintainability.
• Difficult to Reason About: Abruptly jumping around disrupts the normal top-down flow of code, making it harder for the reader (and you!) to understand what’s happening.
• Breaks Structure: goto makes it hard to think about functions as units with well-defined entry and exit points which make it hard to understand.
• Less Robust than try-catch: There is no way to handle different types of errors, all the errors will be handled in one place.

When Should You Maybe Use goto? 🤔

• For Resource Cleanup: When you need to ensure that memory is freed or files are closed, and you have multiple exit points in a function, goto to a single cleanup location can sometimes simplify this.
• Very Simple Cases: For very small functions with limited error handling scenarios, using goto might be tolerable. This is usually only applicable for very specific cases and should be done with caution.

When to Definitely Avoid goto: ⛔

• Complex Logic: Avoid goto if you have complex, nested loops, or lots of conditional statements. It’s likely to make your code unmaintainable.
• General Error Handling: Don’t use goto as your primary way to handle different types of errors.
• When there is an alternative: Try to use if, else or error checking with function return values. This usually makes the code easier to follow.

Alternatives to goto for Error Handling 💡

Luckily, there are usually better options!

• Function Return Values: Return error codes (like -1, NULL, etc.) from functions and use conditional statements to handle them.
• Error Handling Libraries: Consider using existing libraries or implementing some of the functionalities that are used to report errors and handle them.
• Improved Code Structure: Make sure the code is well structured, modular, and has clear entry and exit points. This will also improve the readability and maintainability of the code.

Final Thoughts 💭

While goto has its uses, particularly for basic resource cleanup in C when no advanced language feature exists, it’s not a tool to use indiscriminately. Clarity and readability should always be your main concern when writing code. Use it judiciously and carefully, being fully aware of its shortcomings. In most cases, other error-handling techniques offer a much more robust and maintainable solution!

Resources:

• Stack Overflow Discussion on goto for error handling
• Coding Horror: goto considered harmful
• A detailed explanation of goto in C from geeksforgeeks

Handling File Errors in C 📁: A Friendly Guide

Hey there, fellow coder! 👋 Let’s dive into the world of file operations in C and how to gracefully handle those pesky errors that can pop up. Dealing with files is a powerful tool, but it also comes with its set of challenges. Don’t worry; we’ll break it down step-by-step with simple explanations and examples.

Why Error Handling Matters in File Operations? 🤔

Imagine you’re trying to open a file to read some important data, but…

• The file doesn’t exist. 👻
• You don’t have the right permissions to access it. 🔒
• The disk is full when trying to write. 💾💥
• Something goes wrong during the reading or writing process. 😵‍💫

If your program doesn’t handle these situations, it might crash, corrupt data, or simply behave unexpectedly. Good error handling makes your code robust, reliable, and user-friendly.

Common Errors You Might Encounter 🤕

Here’s a quick rundown of the typical errors you’ll face:

• File Not Found: The file you’re trying to open simply isn’t there.
• Permission Denied: Your program doesn’t have the necessary access rights.
• Disk Full: No more space to write data.
• Read/Write Errors: Something goes wrong during the data transfer.
• Invalid File Modes: You are trying to open a file in the wrong mode for the operation you want to perform.

How C Reports Errors 📣

C uses the errno variable (defined in <errno.h>) to report errors. Functions like fopen, fread, fwrite, etc., set errno when they fail. Always check for return values (like NULL from fopen) and examine errno if needed.

Strategies for Handling Errors 🛠️

Let’s explore how to tackle these errors with some cool techniques.

1. Checking Return Values 🧐

This is your first line of defense. Most file operation functions return a specific value to indicate success or failure.

• fopen(): Returns a file pointer (FILE*) if successful, NULL if it fails.
• fread() and fwrite(): Return the number of elements successfully read or written.
• fclose(): Returns 0 if the file was closed successfully, EOF if an error occurs.

#include <stdio.h>
#include <errno.h>
#include <string.h>

int main() {
    FILE *file = fopen("my_file.txt", "r"); // Try to open in read mode

    if (file == NULL) {
        // Error occurred!
        printf("Error opening the file: %s\n", strerror(errno));
        return 1; // Indicate failure
    } else {
        printf("File opened successfully! 🎉\n");
        // Perform operations with the file
        fclose(file); // Don't forget to close the file
        return 0; // Indicate success
    }
}

Key Takeaway: Always check the return value!

2. Using strerror(errno) 📝

When an error happens, errno gets set. The strerror() function (from <string.h>) takes the errno value and returns a human-readable error message.

#include <stdio.h>
#include <errno.h>
#include <string.h>

int main() {
  FILE *file = fopen("non_existent_file.txt", "r");

  if (file == NULL) {
    printf("Error opening file: %s\n", strerror(errno));
    if (errno == ENOENT){
        printf("File does not exist, please ensure the file path is correct\n");
        return 1;
    } else if (errno == EACCES){
        printf("Permission Denied, make sure you have the correct access rights\n");
        return 1;
    }
    return 1;
  } else {
    // do something with file...
    fclose(file);
    return 0;
  }
}

Key Takeaway: strerror() provides helpful context for debugging.

3. Using Specific errno Values 🕵️

Sometimes, you might want to handle different errors in different ways. You can compare errno to specific error codes (defined in <errno.h>), such as ENOENT (file not found), EACCES (permission denied), etc.

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h> // For the access() function

int main() {
 const char *filename = "my_important_file.txt";

 // Check if file is accessible
 if (access(filename, F_OK) != 0) {
     if(errno == ENOENT){
         printf("File does not exist\n");
         return 1;
     }
     printf("Other error occurred: %s\n", strerror(errno));
     return 1;
 }
 if (access(filename, R_OK) != 0) {
       if (errno == EACCES){
          printf("Error: Permission Denied\n");
         return 1;
       }
       printf("Other error occurred: %s\n", strerror(errno));
       return 1;
 }


  FILE *file = fopen(filename, "r");

 if (file == NULL) {
       if (errno == ENOENT){
        printf("File does not exist, please ensure the file path is correct\n");
        return 1;
      } else if (errno == EACCES){
          printf("Permission Denied, make sure you have the correct access rights\n");
         return 1;
       }
   printf("Error opening file: %s\n", strerror(errno));
   return 1;

 } else {
     printf("File opened successfully!\n");
     // perform actions with the file...
      fclose(file);
 return 0;
 }
}

Key Takeaway: Specific error checking allows you to tailor your response to the problem.

4. Graceful Error Handling (User Messages) 📢

Instead of just printing generic error messages, give the user information that’s actually helpful.

• Instead of: Error opening file, say: Could not open 'my_file.txt'. Please check if the file exists and you have the right permissions.
• If there’s a permission issue: You do not have permission to open this file.

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h> // for EXIT_FAILURE

int main() {
    FILE *file = fopen("config.txt", "r");

    if (file == NULL) {
        if (errno == ENOENT) {
          fprintf(stderr, "Error: The config file 'config.txt' was not found.\n"
                          "Please make sure the file exists in the current directory.\n");
            exit(EXIT_FAILURE);
        } else if (errno == EACCES) {
            fprintf(stderr, "Error: You don't have permission to open 'config.txt'.\n"
                            "Please check the file permissions and try again.\n");
            exit(EXIT_FAILURE);
        } else {
          fprintf(stderr, "An unexpected error occurred: %s\n", strerror(errno));
            exit(EXIT_FAILURE);
        }
    }
   printf("Successfully opened file!\n");
    fclose(file); // don't forget to close it
  return 0;
}

Key Takeaway: Friendly messages make your program more user-friendly.

5. Error Handling Flowchart 🗺️

Here’s a visual representation of how the error checking and handling process looks:

flowchart TD
    A[🔹 Start File Operation] --> B{⚙️ Check Return Value?}
    B -- Yes --> C{❓ Error?}
    C -- Yes --> D{❌ Check errno?}
    D -- Yes --> E[🛠️ Handle Specific Error]
    D -- No --> F[⚠️ Handle Generic Error]
    C -- No --> G[✅ Continue File Operation]
    E --> H[📜 Display error message]
    F --> H
    H --> I[🔄 Exit or Retry]
    G --> J[🔒 Close File]
    J --> K[✅ End Operation]
    I --> K

    class A startNode
    class B decisionNode
    class C decisionNode
    class D decisionNode
    class E processNode
    class F processNode
    class G processNode
    class H processNode
    class I processNode
    class J processNode
    class K returnNode

    classDef startNode fill:#00BFAE,stroke:#00796B,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef decisionNode fill:#FFD54F,stroke:#F57F17,color:#000000,font-size:16px,stroke-dasharray: 5,5;
    classDef returnNode fill:#4CAF50,stroke:#388E3C,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef processNode fill:#FF6F61,stroke:#D32F2F,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10px;

Key Takeaway: Visualizing the process helps clarify the steps.

Best Practices for File Error Handling ✅

• Always Check: Always check return values from file functions.
• Use strerror(): Get helpful error messages with strerror().
• Specific Errors: Check errno for specific error types when appropriate.
• Friendly Messages: Communicate errors clearly to the user.
• Handle, Don’t Ignore: Don’t let errors silently fail; address them in your code.
• Resource Management: Ensure that you always close a file using the fclose function. In cases where errors occur during file operations, remember to close any file handles already opened to prevent resource leaks.

Additional Resources 📚

• C File I/O: Comprehensive article on C file handling.
• C Error Handling: Detailed explanation of error handling in C.
• Errno and Error Codes: GNU documentation on error codes.

Conclusion 🎉

Handling errors in file operations is a crucial skill for writing robust C programs. By using return values, strerror(), errno, and providing clear user messages, you can create applications that handle problems gracefully and keep your users happy. Happy coding! 🚀

Alright, let’s dive into handling errors in C with a friendly approach! We’ll create a program that shows how to deal with divide-by-zero errors and other tricky situations, using clear explanations and visuals. 🚀

Handling Exceptions in C: A Friendly Guide 🛠️

We often encounter unexpected situations in programs - these are called exceptions. These can range from simple things like trying to divide by zero to complex problems like running out of memory. Let’s see how to handle them gracefully in C.

Understanding the Need for Error Handling 🧐

• Why can’t we ignore errors? Imagine a calculator trying to divide by zero – without proper handling, this could lead to the program crashing or returning incorrect results. Nobody wants that! 🙅‍♀️
• What are common exceptions? Some common culprits include:
  • Divide-by-zero errors ➗: When you try to divide a number by zero.
  • File-not-found errors 🗂️: When a program tries to open a file that doesn’t exist.
  • Memory allocation errors 💾: When the system runs out of memory for our program.
• How do we handle errors? In C, we can use mechanisms like if statements, return codes, and error codes to deal with these situations. Let’s focus on if statements in our example for simplicity.

The Divide-by-Zero Exception: A Concrete Example ➗

Let’s start with the classic divide-by-zero error. Here’s a simple program with built-in error handling:

#include <stdio.h>
#include <stdbool.h> // Required for boolean type

// Function to perform division with error checking
bool divide(int numerator, int denominator, float *result) {
  if (denominator == 0) {
    printf("Error: Division by zero!\n");
    return false; // Indicate an error
  }
  *result = (float)numerator / denominator;
  return true;    // Indicate success
}


int main() {
  int num1 = 10;
  int num2 = 0; // We are intentionally setting to zero to trigger an error
  float result;

    if (divide(num1, num2, &result)) {
        printf("Result: %f\n", result);
    } else{
        printf("Oops!, the division operation did not complete successfully!\n");
    }


    num2 = 2; // Resetting it to a valid value
     if (divide(num1, num2, &result)) {
        printf("Result: %f\n", result);
    } else{
        printf("Oops!, the division operation did not complete successfully!\n");
    }


  return 0;
}

Logic Explained

1. divide function:

   • Takes the numerator, denominator, and a pointer to the result variable.
   • Error Check: It first checks if the denominator is zero using if (denominator == 0).
   • Error Handling: If the denominator is zero, it prints an error message and returns false, indicating the operation failed.
   • Success: Otherwise, it performs the division, stores the result in the memory location pointed to by result and returns true, indicating the operation succeeded.

2. main function:

   • It initializes two numbers (num1, num2). One to perform valid division and another to perform divide by zero
   • It calls the divide function passing num1, num2, and the address of result variable (&result).
   • Result Handling: The function returns a boolean value and based on that boolean value the main function either prints the result or error message.

Visualizing the Flow

graph LR
    A[🔹 Start] --> B{❓ Denominator == 0?}
    B -- Yes --> C[⚠️ Print Error Message]
    C --> D[❌ Return False]
    B -- No --> E[➗ Perform Division]
    E --> F[💾 Store Result]
    F --> G[✅ Return True]
    D --> H[🔚 End]
    G --> H

    class A startNode
    class B decisionNode
    class C processNode
    class D returnNode
    class E processNode
    class F processNode
    class G returnNode
    class H endNode

    classDef startNode fill:#00BFAE,stroke:#00796B,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef decisionNode fill:#FFD54F,stroke:#F57F17,color:#000000,font-size:16px,stroke-dasharray: 5,5;
    classDef processNode fill:#FF6F61,stroke:#D32F2F,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10px;
    classDef returnNode fill:#4CAF50,stroke:#388E3C,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef endNode fill:#9E9E9E,stroke:#757575,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;

Handling Multiple Exceptions 🚨

We can extend this approach to handle more types of errors, although C lacks built-in exception handling. Let’s make the divide function check for invalid negative denominators and print the reason for the error:

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


typedef enum {
  DIVIDE_SUCCESS,
  DIVIDE_BY_ZERO_ERROR,
  DIVIDE_NEGATIVE_DENOMINATOR_ERROR,
  DIVIDE_UNKNOWN_ERROR
} DivideStatus;


// Updated function to check for negative denominators
DivideStatus divide_multiple(int numerator, int denominator, float *result) {

    if (denominator == 0) {
        printf("Error: Division by zero!\n");
        return DIVIDE_BY_ZERO_ERROR;
    } else if (denominator < 0) {
        printf("Error: Negative denominator not allowed!\n");
        return DIVIDE_NEGATIVE_DENOMINATOR_ERROR;
    }
    *result = (float)numerator / denominator;
    return DIVIDE_SUCCESS;
}



int main() {
    int num1 = 10;
    int num2 = 0;
    float result;
    DivideStatus status;

    status = divide_multiple(num1, num2, &result);
    if (status == DIVIDE_SUCCESS) {
       printf("Result: %f\n", result);
    } else if (status == DIVIDE_BY_ZERO_ERROR) {
        printf("Oops!, division by zero detected!\n");
    } else if (status == DIVIDE_NEGATIVE_DENOMINATOR_ERROR){
        printf("Oops!, negative denominator not allowed\n");
    }


    num2 = -2; //negative denominator
    status = divide_multiple(num1, num2, &result);
    if (status == DIVIDE_SUCCESS) {
       printf("Result: %f\n", result);
    } else if (status == DIVIDE_BY_ZERO_ERROR) {
        printf("Oops!, division by zero detected!\n");
    } else if (status == DIVIDE_NEGATIVE_DENOMINATOR_ERROR){
        printf("Oops!, negative denominator not allowed\n");
    }
     num2 = 2; // Resetting it to a valid value

      status = divide_multiple(num1, num2, &result);
    if (status == DIVIDE_SUCCESS) {
       printf("Result: %f\n", result);
    } else if (status == DIVIDE_BY_ZERO_ERROR) {
        printf("Oops!, division by zero detected!\n");
    } else if (status == DIVIDE_NEGATIVE_DENOMINATOR_ERROR){
        printf("Oops!, negative denominator not allowed\n");
    }

    return 0;
}

Logic Explained

1. divide_multiple function:

   • It uses an enum to define different status codes for the various exceptions.
   • Error Checks: Now, it checks for both zero denominator and negative denominators using if-else.
   • Error Handling: Returns corresponding error code on failure.
   • Success: Returns DIVIDE_SUCCESS and stores the result in result variable on successful completion.

2. main function:

   • It calls the divide_multiple function.
   • Result Handling: It handles the returned error code via if-else and prints the message relevant to the error code that is returned.

Visualizing the Flow

graph LR
    A[🔹 Start] --> B{❓ Denominator == 0?}
    B -- Yes --> C[⚠️ Print Error Message 1]
    C --> D[❌ Return DIVIDE_BY_ZERO_ERROR]
    B -- No --> E{❓ Denominator < 0?}
    E -- Yes --> F[⚠️ Print Error Message 2]
    F --> G[❌ Return DIVIDE_NEGATIVE_DENOMINATOR_ERROR]
    E -- No --> H[➗ Perform Division]
    H --> I[💾 Store Result]
    I --> J[✅ Return DIVIDE_SUCCESS]
    D --> K[🔚 End]
    G --> K
    J --> K

    class A startNode
    class B decisionNode
    class C processNode
    class D returnNode
    class E decisionNode
    class F processNode
    class G returnNode
    class H processNode
    class I processNode
    class J returnNode
    class K endNode

    classDef startNode fill:#00BFAE,stroke:#00796B,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef decisionNode fill:#FFD54F,stroke:#F57F17,color:#000000,font-size:16px,stroke-dasharray: 5,5;
    classDef processNode fill:#FF6F61,stroke:#D32F2F,color:#FFFFFF,font-size:14px,stroke-width:2px,rx:10px;
    classDef returnNode fill:#4CAF50,stroke:#388E3C,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;
    classDef endNode fill:#9E9E9E,stroke:#757575,color:#FFFFFF,font-size:16px,stroke-width:2px,rx:10px;

Key Takeaways 📝

• Error checking is crucial: It prevents program crashes and ensures the program handles unexpected scenarios properly. 🛡️
• Return codes or enums are common: They help indicate success or different types of errors.
• Simple if statements: Can handle basic error conditions in a straightforward way.
• Using meaningful enums: Make the code more organized and easier to understand.

Resources for Further Learning 📚

• C Error Handling:

• Tutorialspoint Error Handling: A tutorial explaining different error handling techniques in C.

• C enum:
• GeeksforGeeks C enum: A great resource on how to use and why to use enum in C

That’s it! We’ve explored how to gracefully handle exceptions, like division by zero and other errors in C. Remember, error handling is a vital part of writing robust and reliable code. Happy coding! 🎉

Conclusion

And that’s a wrap! 🎉 We hope you found this blog post helpful and insightful. We’re always looking to improve and learn, so we’d love to hear from you! What are your thoughts? Did anything resonate with you? 🤔 Maybe you have a suggestion or something you’d like us to explore next? Share your comments, feedback, and ideas below! 👇 We’re excited to hear what you have to say! 😊 Let’s keep the conversation going! 💬