CoreTechED

Loading

Tag signal handling

Learn C signals: signal handling, raise, kill, signal types, and custom handlers. Master asynchronous event handling in C.
C Programming

Signals in C Language: Complete Guide

Signals in C Language: A Comprehensive Tutorial

A signal is a software-generated interrupt sent to a process by the operating system or another process to notify it about an event. Signals provide a mechanism for inter-process communication and handling asynchronous events. Understanding signals is essential for writing robust programs that respond gracefully to user actions and system events.

This tutorial provides an in-depth exploration of signals in C: signal handling, default handlers, user-defined handlers, raise(), kill(), signal types, common pitfalls, and best practices.

Conceptual Introduction & Fundamentals

What is a Signal?

A signal is a notification delivered to a process by the operating system or another process. Signals interrupt the normal flow of execution to handle events such as:

  • User actions (pressing Ctrl+C)
  • Hardware exceptions (division by zero)
  • Software errors (segmentation fault)
  • Process control (termination requests)

Why Signals Matter

  • Event notification: Inform processes about important events.
  • Asynchronous handling: Handle events at any time during execution.
  • Process management: Terminate, stop, or continue processes.
  • Error recovery: Handle hardware/software exceptions.
  • Inter-process communication: Send messages between processes.

Signal Characteristics

  • Each signal has a unique integer identifier (e.g., SIGINT = 2).
  • Signals can be generated by the OS, user, or other processes.
  • Default actions: terminate, ignore, stop, or continue.
  • Custom handlers can replace default behavior (except SIGKILL).

Common Signal Types

SignalDescriptionDefault Action
SIGINTInterrupt (Ctrl+C)Terminate
SIGTERMTermination requestTerminate
SIGKILLForceful terminationTerminate (cannot be caught)
SIGSEGVSegmentation faultTerminate (core dump)
SIGFPEFloating-point exceptionTerminate
SIGABRTAbnormal terminationTerminate (core dump)
SIGCHLDChild process terminatedIgnore
SIGCONTContinue stopped processContinue
SIGTSTPTerminal stop (Ctrl+Z)Stop

Syntax & Core Mechanics

Default Signal Handling

Without custom handlers, signals use their default actions.

c

#include <stdio.h> int main(void) { while (1) { printf("Hello World\n"); } return 0; }

Output (infinite loop, terminated by Ctrl+C):

text

Hello World Hello World Hello World ... ^C

Pressing Ctrl+C sends SIGINT, which terminates the process.

User-Defined Signal Handlers

Use signal() to register custom handlers.

Syntax:

c

void (*signal(int sig, void (*handler)(int)))(int);

Example:

c

#include <stdio.h> #include <signal.h> #include <stdlib.h> #include <unistd.h> void signalHandler(int sig) { const char msg[] = "Caught SIGINT\n"; write(STDOUT_FILENO, msg, sizeof(msg) - 1); _exit(sig); } int main(void) { signal(SIGINT, signalHandler); while (1) { printf("Hello World!\n"); sleep(1); } return 0; }

Output (Ctrl+C pressed):

text

Hello World! Hello World! Hello World! ^CCaught SIGINT

Note: Use write() (not printf) in signal handlers for safety.

Registering Multiple Signal Handlers

c

#include <stdio.h> #include <signal.h> #include <stdlib.h> #include <unistd.h> void handleSignal(int sig) { switch (sig) { case SIGINT: write(STDOUT_FILENO, "Caught SIGINT\n", 14); break; case SIGTERM: write(STDOUT_FILENO, "Caught SIGTERM\n", 15); break; case SIGUSR1: write(STDOUT_FILENO, "Caught SIGUSR1\n", 15); break; } } int main(void) { signal(SIGINT, handleSignal); signal(SIGTERM, handleSignal); signal(SIGUSR1, handleSignal); printf("PID: %d\n", getpid()); printf("Press Ctrl+C or send signals.\n"); while (1) { sleep(1); } return 0; }

raise() — Send Signal to Self

Sends a signal to the current process.

Syntax:

c

int raise(int sig);

Example:

c

#include <stdio.h> #include <stdlib.h> #include <signal.h> void signalHandler(int sig) { printf("Interrupt handled: %d\n", sig); exit(sig); } int main(void) { signal(SIGINT, signalHandler); printf("Raising SIGINT...\n"); raise(SIGINT); /* This line won't be reached */ printf("After raise\n"); return 0; }

Expected output:

text

Raising SIGINT... Interrupt handled: 2

kill() — Send Signal to Process

Sends a signal to another process using its PID.

Syntax:

c

int kill(pid_t pid, int sig);

Example:

c

#include <stdio.h> #include <stdlib.h> #include <signal.h> #include <unistd.h> void handleSignal(int sig) { printf("Received signal: %d\n", sig); } int main(void) { signal(SIGINT, handleSignal); pid_t pid = getpid(); printf("Sending SIGINT to PID %d\n", pid); kill(pid, SIGINT); return 0; }

Expected output:

text

Sending SIGINT to PID 12345 Received signal: 2

Full Practical Code Example with Explanation

This program demonstrates signals in a realistic scenario: a robust daemon-like process with signal handling.

Program: Signal Handling Demo

c

/** * signal_demo.c * Demonstrates signal handling with custom handlers, raise, and kill. * Includes graceful shutdown and multiple signal types. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <signal.h> #include <unistd.h> #include <errno.h> /* Global flags for signal handling */ volatile sig_atomic_t signalReceived = 0; volatile sig_atomic_t signalNumber = 0; /* Signal handler function */ void signalHandler(int sig) { signalReceived = 1; signalNumber = sig; /* Use write() for safety in signal handlers */ const char *msg = "Signal received!\n"; write(STDOUT_FILENO, msg, strlen(msg)); } /* Function prototypes */ void demonstrateDefaultSignals(void); void demonstrateCustomHandler(void); void demonstrateRaise(void); void demonstrateKill(void); void demonstrateMultipleSignals(void); const char *getSignalName(int sig); int main(void) { int choice; char buffer[100]; printf("=== Signal Handling Demo ===\n"); printf("Process PID: %d\n", getpid()); while (1) { printf("\n--- Menu ---\n"); printf("1. Demonstrate Default Signals\n"); printf("2. Demonstrate Custom Handler\n"); printf("3. Demonstrate raise()\n"); printf("4. Demonstrate kill()\n"); printf("5. Demonstrate Multiple Signals\n"); printf("6. Exit\n"); printf("Enter choice: "); fflush(stdout); if (fgets(buffer, sizeof(buffer), stdin) == NULL) { fprintf(stderr, "Error reading choice.\n"); return EXIT_FAILURE; } choice = atoi(buffer); switch (choice) { case 1: demonstrateDefaultSignals(); break; case 2: demonstrateCustomHandler(); break; case 3: demonstrateRaise(); break; case 4: demonstrateKill(); break; case 5: demonstrateMultipleSignals(); break; case 6: printf("Exiting.\n"); return EXIT_SUCCESS; default: printf("Invalid choice. Please try again.\n"); break; } } return EXIT_SUCCESS; } /* Demonstrates default signal behavior */ void demonstrateDefaultSignals(void) { printf("\n=== Default Signals ===\n"); printf("This program would terminate on Ctrl+C.\n"); printf("But we won't wait for that.\n"); } /* Demonstrates custom signal handler */ void demonstrateCustomHandler(void) { printf("\n=== Custom Signal Handler ===\n"); /* Register handler for SIGINT */ signal(SIGINT, signalHandler); printf("SIGINT handler registered. Press Ctrl+C to test.\n"); printf("Waiting for signal...\n"); /* Wait for signal */ int count = 0; while (signalReceived == 0 && count < 10) { sleep(1); printf("Waiting... (%d/10)\n", ++count); } if (signalReceived) { printf("Signal '%s' was received.\n", getSignalName(signalNumber)); } else { printf("No signal received (timeout).\n"); } /* Reset */ signalReceived = 0; signal(SIGINT, SIG_DFL); } /* Demonstrates raise() */ void demonstrateRaise(void) { printf("\n=== raise() ===\n"); signal(SIGUSR1, signalHandler); printf("Raising SIGUSR1...\n"); if (raise(SIGUSR1) != 0) { perror("raise"); } if (signalReceived) { printf("Signal '%s' raised successfully.\n", getSignalName(signalNumber)); } signalReceived = 0; signal(SIGUSR1, SIG_DFL); } /* Demonstrates kill() */ void demonstrateKill(void) { printf("\n=== kill() ===\n"); signal(SIGUSR2, signalHandler); pid_t pid = getpid(); printf("Sending SIGUSR2 to PID %d...\n", pid); if (kill(pid, SIGUSR2) != 0) { perror("kill"); } if (signalReceived) { printf("Signal '%s' sent successfully.\n", getSignalName(signalNumber)); } signalReceived = 0; signal(SIGUSR2, SIG_DFL); } /* Demonstrates multiple signal handlers */ void demonstrateMultipleSignals(void) { printf("\n=== Multiple Signals ===\n"); /* Register multiple handlers */ signal(SIGINT, signalHandler); signal(SIGTERM, signalHandler); signal(SIGUSR1, signalHandler); printf("Registered handlers for SIGINT, SIGTERM, SIGUSR1.\n"); printf("Sending all three signals...\n"); /* Send signals using raise */ raise(SIGINT); signalReceived = 0; raise(SIGTERM); signalReceived = 0; raise(SIGUSR1); signalReceived = 0; printf("All signals handled.\n"); /* Reset handlers */ signal(SIGINT, SIG_DFL); signal(SIGTERM, SIG_DFL); signal(SIGUSR1, SIG_DFL); } /* Returns string representation of signal */ const char *getSignalName(int sig) { switch (sig) { case SIGINT: return "SIGINT"; case SIGTERM: return "SIGTERM"; case SIGUSR1: return "SIGUSR1"; case SIGUSR2: return "SIGUSR2"; case SIGSEGV: return "SIGSEGV"; case SIGFPE: return "SIGFPE"; default: return "UNKNOWN"; } }

Explanation of Signal Usage

  1. Default handlers: Signals terminate process unless caught.
  2. Custom handler: signalHandler sets flags and prints message.
  3. raise(): Sends signal to current process.
  4. kill(): Sends signal by PID.
  5. Multiple signals: Register and handle different signals.
  6. volatile sig_atomic_t: Safe flag type for signal handlers.

Expected Output (sample run)

text

=== Signal Handling Demo === Process PID: 12345 --- Menu --- 1. Demonstrate Default Signals 2. Demonstrate Custom Handler 3. Demonstrate raise() 4. Demonstrate kill() 5. Demonstrate Multiple Signals 6. Exit Enter choice: 2 === Custom Signal Handler === SIGINT handler registered. Press Ctrl+C to test. Waiting for signal... Waiting... (1/10) Waiting... (2/10) ^CSignal received! Signal 'SIGINT' was received. --- Menu --- ... Enter choice: 3 === raise() === Raising SIGUSR1... Signal received! Signal 'SIGUSR1' raised successfully. --- Menu --- ... Enter choice: 5 === Multiple Signals === Registered handlers for SIGINT, SIGTERM, SIGUSR1. Sending all three signals... Signal received! Signal received! Signal received! All signals handled.

Common Pitfalls, Edge Cases & Memory Considerations

1. Using printf in Signal Handlers

printf is not async-signal-safe; using it in handlers can cause corruption.

c

void handler(int sig) { printf("Signal %d\n", sig); // BUG: not safe }

Solution: Use write() or set a flag and handle later.

2. Not Using volatile sig_atomic_t

Shared variables between handler and main code must be volatile sig_atomic_t.

c

int flag = 0; // BUG: not volatile void handler(int sig) { flag = 1; }

Solution: Use volatile sig_atomic_t flag = 0;

3. Resetting Signal Handler

Some systems reset the handler after invocation; re-register inside handler.

c

void handler(int sig) { signal(sig, handler); // Re-register /* Handle signal */ }

Solution: Re-register handler or use sigaction for persistent handlers.

4. Catching SIGKILL

SIGKILL cannot be caught, blocked, or ignored.

c

signal(SIGKILL, handler); // No effect

Solution: Do not attempt to handle SIGKILL.

5. Not Checking signal Return

signal returns SIG_ERR on failure.

c

signal(SIGINT, handler); // No check

Solution: Check if (signal(SIGINT, handler) == SIG_ERR).

6. Using raise Without Handler

If no handler is registered, raise uses default action (terminate).

c

raise(SIGINT); // Terminates if no handler

Solution: Register handler before raising signals.

7. kill with Invalid PID

Sending signals to non-existent processes fails.

c

kill(999999, SIGTERM); // May fail

Solution: Check kill return value and handle errors.

8. Race Conditions

Signal handlers can interrupt at any point, causing race conditions.

Solution: Use sig_atomic_t flags and minimize handler complexity.

9. Blocking Signals

Use sigprocmask to block signals temporarily.

c

sigset_t set; sigemptyset(&set); sigaddset(&set, SIGINT); sigprocmask(SIG_BLOCK, &set, NULL); /* Critical section */ sigprocmask(SIG_UNBLOCK, &set, NULL);

10. Memory Considerations

  • Signal handlers should allocate minimal resources.
  • Use write() for output (not printf/malloc).
  • volatile sig_atomic_t is typically an integer.
  • Avoid global state mutation in handlers where possible.

Summary & Best Practices

Signals provide a mechanism for asynchronous event notification in C. Proper handling ensures programs respond gracefully to user actions and system events.

Key Takeaways

  • Signals are software interrupts with integer identifiers.
  • Default actions: terminate, ignore, stop, continue.
  • signal() registers custom handlers.
  • raise() sends signals to self.
  • kill() sends signals to other processes.
  • Use write() in handlers for safety.
  • Use volatile sig_atomic_t for flags.

Best Practices

  1. Use write() instead of printf in handlers.
  2. Use volatile sig_atomic_t for flags.
  3. Keep handlers minimal (set flags, do simple I/O).
  4. Check signal return value for errors.
  5. Re-register handlers if the system resets them.
  6. Do not handle SIGKILL (impossible).
  7. Use sigaction instead of signal for portability.
  8. Block signals during critical sections using sigprocmask.
  9. Document signal behavior in comments.
  10. Test with different signals and edge cases.

By mastering signals, you’ll write robust C programs that handle asynchronous events and communicate effectively with the operating system.

Learn to handle division by zero in C: manual checking, signal handling (SIGFPE), and setjmp/longjmp recovery. Master robust error handling.
C Programming

C Program to Handle Divide by Zero: Complete Guide

C Program to Handle Divide by Zero: A Comprehensive Tutorial

In C programming, there is no built-in exception handling like in other high-level languages such as C++, Java, or Python. However, you can still handle exceptions using error checking, function return values, or signal handlers. Division by zero is a common runtime error that must be handled properly to prevent crashes and undefined behavior.

This tutorial provides an in-depth exploration of handling divide-by-zero in C: manual checking, signal handling, practical applications, common pitfalls, and best practices.

Conceptual Introduction & Fundamentals

What is Division by Zero?

Division by zero occurs when a program attempts to divide a number by zero. In mathematics, this operation is undefined. In C:

  • Integer division by zero: Undefined behavior (often causes a crash/SIGFPE signal).
  • Floating-point division by zero: Produces infinity (inf) or NaN, depending on the operation.

Example:

c

int a = 10, b = 0; int result = a / b; // Undefined behavior (crash on most systems)

Why Handle Division by Zero?

  • Prevent crashes: Avoid program termination from SIGFPE.
  • Data integrity: Ensure calculations are valid.
  • User experience: Provide clear error messages.
  • Robustness: Handle unexpected input gracefully.
  • Debugging: Identify division-by-zero errors during development.

Two Approaches

ApproachDescriptionProsCons
Manual checkingCheck divisor before divisionSimple, portableRequires explicit checks
Signal handlingCatch SIGFPE with signal handlerHandles unexpected errorsComplex, less portable

Syntax & Core Mechanics

Method 1: Manual Checking

The most straightforward approach is to check the divisor before division.

c

#include <stdio.h> int main(void) { float a = 10, b = 0; float result; /* Check for division by zero */ if (b == 0) { printf("Error: Division by zero\n"); return 1; } result = a / b; printf("Result: %.2f\n", result); return 0; }

Expected output:

text

Error: Division by zero

Manual Checking with Function

Encapsulate division in a function with error checking.

c

#include <stdio.h> #include <stdbool.h> bool safeDivide(double numerator, double denominator, double *result) { if (denominator == 0) { return false; // Error: division by zero } *result = numerator / denominator; return true; // Success } int main(void) { double a = 10, b = 0; double result; if (safeDivide(a, b, &result)) { printf("Result: %.2f\n", result); } else { fprintf(stderr, "Error: Division by zero\n"); } return 0; }

Expected output:

text

Error: Division by zero

Method 2: Signal Handling

Use signal() to catch SIGFPE (Floating Point Exception).

c

#include <stdio.h> #include <signal.h> #include <stdlib.h> void handleDivideByZero(int sig) { printf("Error: Division by zero detected (SIGFPE)\n"); exit(EXIT_FAILURE); } int main(void) { /* Register signal handler */ signal(SIGFPE, handleDivideByZero); int a = 10, b = 0; int result = a / b; // Triggers SIGFPE printf("Result: %d\n", result); return 0; }

Expected output:

text

Error: Division by zero detected (SIGFPE)

Signal Handling with setjmp/longjmp

Use setjmp/longjmp to recover from the error without exiting.

c

#include <stdio.h> #include <signal.h> #include <setjmp.h> #include <stdlib.h> jmp_buf recoveryPoint; void handleDivideByZero(int sig) { printf("Error: Division by zero\n"); longjmp(recoveryPoint, 1); // Jump back to recovery point } int main(void) { signal(SIGFPE, handleDivideByZero); if (setjmp(recoveryPoint) == 0) { int a = 10, b = 0; int result = a / b; // Triggers SIGFPE printf("Result: %d\n", result); } else { printf("Recovered from division by zero.\n"); } printf("Program continues after recovery.\n"); return 0; }

Expected output:

text

Error: Division by zero Recovered from division by zero. Program continues after recovery.

Full Practical Code Example with Explanation

This program demonstrates both manual checking and signal handling for division by zero in a calculator application.

Program: Safe Division Calculator

c

/** * divide_by_zero_handler.c * Demonstrates division by zero handling using manual checking * and signal handling. */ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <signal.h> #include <setjmp.h> #include <errno.h> #include <string.h> #define MAX_LINE_LEN 100 /* Jump buffer for signal recovery */ jmp_buf recoveryPoint; volatile sig_atomic_t divisionByZeroDetected = 0; /* Function prototypes */ bool safeDivideManual(double numerator, double denominator, double *result); void handleSIGFPE(int sig); int demonstrateManualChecking(void); int demonstrateSignalHandling(void); int demonstrateInteractiveCalculator(void); double readNumber(const char *prompt); int main(void) { int choice; char buffer[MAX_LINE_LEN]; printf("=== Division by Zero Handler ===\n"); while (1) { printf("\n--- Menu ---\n"); printf("1. Manual Checking Demo\n"); printf("2. Signal Handling Demo\n"); printf("3. Interactive Calculator\n"); printf("4. Exit\n"); printf("Enter choice: "); fflush(stdout); if (fgets(buffer, sizeof(buffer), stdin) == NULL) { fprintf(stderr, "Error reading choice.\n"); return EXIT_FAILURE; } choice = atoi(buffer); switch (choice) { case 1: demonstrateManualChecking(); break; case 2: demonstrateSignalHandling(); break; case 3: demonstrateInteractiveCalculator(); break; case 4: printf("Exiting.\n"); return EXIT_SUCCESS; default: printf("Invalid choice. Please try again.\n"); break; } } return EXIT_SUCCESS; } /* Safely divides using manual checking */ bool safeDivideManual(double numerator, double denominator, double *result) { if (denominator == 0) { return false; // Division by zero } *result = numerator / denominator; return true; } /* Signal handler for SIGFPE */ void handleSIGFPE(int sig) { divisionByZeroDetected = 1; printf("Error: Division by zero detected (SIGFPE)\n"); longjmp(recoveryPoint, 1); } /* Demonstrates manual checking */ int demonstrateManualChecking(void) { printf("\n=== Manual Checking ===\n"); double result; /* Case 1: Valid division */ printf("Case 1: 10 / 2 = "); if (safeDivideManual(10, 2, &result)) { printf("%.2f\n", result); } /* Case 2: Division by zero */ printf("Case 2: 10 / 0 = "); if (safeDivideManual(10, 0, &result)) { printf("%.2f\n", result); } else { printf("Error: Cannot divide by zero.\n"); } /* Case 3: Floating-point division by very small number */ printf("Case 3: 10 / 0.000001 = "); if (safeDivideManual(10, 0.000001, &result)) { printf("%.2f\n", result); } return 0; } /* Demonstrates signal handling */ int demonstrateSignalHandling(void) { printf("\n=== Signal Handling ===\n"); /* Register signal handler */ signal(SIGFPE, handleSIGFPE); printf("Attempting division by zero with signal handler...\n"); if (setjmp(recoveryPoint) == 0) { /* This will trigger SIGFPE */ int a = 10; int b = 0; int result = a / b; // Triggers signal /* This line will not be reached */ printf("Result: %d\n", result); } else { printf("Recovered from division by zero.\n"); printf("Program can continue executing.\n"); } /* Demonstrate integer vs floating-point behavior */ printf("\nFloating-point division by zero:\n"); double x = 10.0, y = 0.0; double result = x / y; if (divisionByZeroDetected) { printf("Division by zero was detected.\n"); } else { printf("Result: %f (infinity)\n", result); printf("Note: Floating-point division by zero produces infinity.\n"); } return 0; } /* Demonstrates interactive calculator with safe division */ int demonstrateInteractiveCalculator(void) { printf("\n=== Interactive Calculator ===\n"); double num1, num2, result; char operation; num1 = readNumber("Enter first number: "); num2 = readNumber("Enter second number: "); printf("Enter operation (+, -, *, /): "); fflush(stdout); char buffer[MAX_LINE_LEN]; if (fgets(buffer, sizeof(buffer), stdin) == NULL) { fprintf(stderr, "Error reading operation.\n"); return -1; } operation = buffer[0]; switch (operation) { case '+': result = num1 + num2; printf("%.2f + %.2f = %.2f\n", num1, num2, result); break; case '-': result = num1 - num2; printf("%.2f - %.2f = %.2f\n", num1, num2, result); break; case '*': result = num1 * num2; printf("%.2f * %.2f = %.2f\n", num1, num2, result); break; case '/': if (safeDivideManual(num1, num2, &result)) { printf("%.2f / %.2f = %.2f\n", num1, num2, result); } else { fprintf(stderr, "Error: Division by zero.\n"); } break; default: fprintf(stderr, "Error: Invalid operation.\n"); break; } return 0; } /* Reads a number safely */ double readNumber(const char *prompt) { char buffer[MAX_LINE_LEN]; char *endPtr; double value; while (1) { printf("%s", prompt); fflush(stdout); if (fgets(buffer, sizeof(buffer), stdin) == NULL) { fprintf(stderr, "Error reading input.\n"); exit(EXIT_FAILURE); } errno = 0; value = strtod(buffer, &endPtr); if (endPtr == buffer || (*endPtr != '\n' && *endPtr != '\0')) { printf("Invalid number. Please try again.\n"); continue; } if (errno == ERANGE) { printf("Number out of range. Please try again.\n"); continue; } return value; } }

Explanation of Division by Zero Handling

  1. Manual checking: safeDivideManual checks denominator before division.
  2. Signal handling: handleSIGFPE catches SIGFPE signal.
  3. setjmp/longjmp: Enables recovery from the error.
  4. Integer vs. floating-point: Integer division by zero triggers SIGFPE; floating-point produces infinity.
  5. Interactive calculator: Combines safe division with user input.

Expected Output (sample run)

text

=== Division by Zero Handler === --- Menu --- 1. Manual Checking Demo 2. Signal Handling Demo 3. Interactive Calculator 4. Exit Enter choice: 1 === Manual Checking === Case 1: 10 / 2 = 5.00 Case 2: 10 / 0 = Error: Cannot divide by zero. Case 3: 10 / 0.000001 = 10000000.00 --- Menu --- ... Enter choice: 2 === Signal Handling === Attempting division by zero with signal handler... Error: Division by zero detected (SIGFPE) Recovered from division by zero. Program can continue executing. Floating-point division by zero: Result: inf (infinity) Note: Floating-point division by zero produces infinity. --- Menu --- ... Enter choice: 3 === Interactive Calculator === Enter first number: 10 Enter second number: 0 Enter operation (+, -, *, /): / Error: Division by zero.

Common Pitfalls, Edge Cases & Memory Considerations

1. Integer Division by Zero is Undefined

Integer division by zero causes undefined behavior (often SIGFPE crash).

c

int a = 10, b = 0; int result = a / b; // Undefined behavior

Solution: Always check b != 0 before integer division.

2. Floating-Point Division by Zero Produces Infinity

Unlike integer division, floating-point division by zero yields inf (or nan for 0/0).

c

double result = 10.0 / 0.0; // Infinity double nan = 0.0 / 0.0; // NaN

Solution: Check for zero and handle according to requirements.

3. Not Registering Signal Handler

Without a signal handler, SIGFPE causes program termination.

Solution: Register a handler using signal(SIGFPE, handler) if signal handling is needed.

4. Signal Handler Portability

Signal handling is not fully portable across all systems.

Solution: Prefer manual checking for portability; use signal handling only when necessary.

5. setjmp/longjmp Complexity

Using setjmp/longjmp adds complexity and can cause resource leaks.

Solution: Use manual checking as the primary approach; use setjmp/longjmp only for advanced recovery.

6. Forgetting to Reset Signal Handler

Some systems reset the signal handler after invocation.

Solution: Re-register the signal handler inside the handler function.

7. Division by Very Small Numbers

Division by very small (but non-zero) numbers can produce very large results, potentially causing overflow.

c

double result = 10.0 / 1e-300; // Very large result

Solution: Check for very small denominators if overflow is a concern.

8. Not Checking Function Return Values

Forgetting to check the boolean return of safeDivide means missing errors.

Solution: Always check function return values.

9. Modulo by Zero

The modulo operator (%) also causes division by zero errors.

c

int result = 10 % 0; // Undefined behavior

Solution: Check b != 0 before modulo operation.

10. Memory Considerations

  • Manual checking uses no extra memory.
  • Signal handlers add slight overhead.
  • setjmp/longjmp save/restore program state (uses stack space).
  • No dynamic memory allocation is needed for division-by-zero handling.

Summary & Best Practices

Division by zero is a common runtime error in C. Manual checking is the preferred, portable approach; signal handling provides a fallback for unexpected errors.

Key Takeaways

  • Integer division by zero is undefined behavior.
  • Floating-point division by zero produces inf or nan.
  • Manual checking: if (denominator == 0) { /* error */ }.
  • Signal handling: signal(SIGFPE, handler) catches floating-point exceptions.
  • setjmp/longjmp enables recovery from errors.
  • Always check the divisor before division.

Best Practices

  1. Always check for zero divisor before division.
  2. Use a safe division function with boolean return.
  3. Prefer manual checking over signal handling for portability.
  4. Use signal handling only for exceptional cases or low-level programming.
  5. Display meaningful error messages to identify the cause.
  6. Check modulo operator for zero as well.
  7. Handle floating-point special values (inf, nan) if needed.
  8. Test with edge cases: zero, very small numbers, negative numbers.
  9. Re-register signal handlers inside the handler for portability.
  10. Document division-by-zero handling in comments.

By mastering division-by-zero handling, you’ll write robust C programs that gracefully handle this common error and prevent crashes.