Common C Language Errors & Debugging Guide

1. Missing Semicolon Issues

Error Example:

#include <stdio.h>

int main() {
    int x = 10
    printf("%d", x);  // ERROR: expected ';' before 'printf'
    return 0;
}

Solution:

#include <stdio.h>

int main() {
    int x = 10;  // CORRECT: Added semicolon
    printf("%d", x);
    return 0;
}

Common Places Missing Semicolons Occur:

• After variable declarations
• After function calls
• After return statements
• After structure member declarations
• After enum declarations

2. Undefined Reference Errors

Error Example:

// undefined reference to printf
// undefined reference to main

Common Causes:

• Missing header file includes
• Function not defined or declared
• Linking errors (missing library files)
• Spelling mistakes in function names

Solutions:

// Include required headers
#include <stdio.h>   // For printf, scanf
#include <string.h>  // For string functions
#include <stdlib.h>  // For malloc, free
#include <math.h>    // For math functions

// Declare functions before use
int add(int a, int b);  // Function prototype

int main() {
    int result = add(5, 3);  // Now it works
    return 0;
}

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

3. Segmentation Fault Explanation

What is Segmentation Fault?

Segmentation fault (segfault) occurs when a program tries to access memory that it doesn't have permission to access. It's one of the most common runtime errors in C.

Common Causes:

a) Null Pointer Dereference:

// ERROR
int *ptr = NULL;
*ptr = 10;  // Segmentation fault!

// CORRECT
int *ptr = NULL;
if (ptr != NULL) {
    *ptr = 10;
} else {
    printf("Pointer is NULL\n");
}

b) Accessing Freed Memory:

// ERROR
int *ptr = malloc(sizeof(int) * 10);
free(ptr);
*ptr = 10;  // Segmentation fault! Memory already freed

// CORRECT
int *ptr = malloc(sizeof(int) * 10);
if (ptr != NULL) {
    *ptr = 10;
}
free(ptr);
ptr = NULL;  // Prevent dangling pointer

c) Stack Overflow:

// ERROR - Infinite recursion
int factorial(int n) {
    return n * factorial(n - 1);  // No base case!
}

// CORRECT
int factorial(int n) {
    if (n <= 1) {
        return 1;  // Base case
    }
    return n * factorial(n - 1);
}

d) Buffer Overflow:

// ERROR
char str[5];
strcpy(str, "Hello World");  // Too long! Segmentation fault

// CORRECT
char str[50];
strncpy(str, "Hello World", sizeof(str) - 1);
str[sizeof(str) - 1] = '\0';

How to Debug Segmentation Faults:

• Use debugger (GDB) with: gdb ./program
• Compile with debugging symbols: gcc -g program.c
• Use Valgrind: valgrind ./program
• Add printf statements to trace execution
• Check all pointer operations

4. Pointer Errors

a) Uninitialized Pointer:

// ERROR
int *ptr;
*ptr = 10;  // Pointer not initialized! Undefined behavior

// CORRECT
int *ptr;
int value = 10;
ptr = &value;  // Initialize pointer
*ptr = 20;     // Now safe

b) Dangling Pointer:

// ERROR
int *ptr = malloc(sizeof(int) * 10);
free(ptr);
*ptr = 10;  // Dangling pointer! Using freed memory

// CORRECT
int *ptr = malloc(sizeof(int) * 10);
if (ptr != NULL) {
    *ptr = 10;
}
free(ptr);
ptr = NULL;  // Set to NULL after freeing

c) Double Free:

// ERROR
int *ptr = malloc(sizeof(int) * 10);
free(ptr);
free(ptr);  // Double free error!

// CORRECT
int *ptr = malloc(sizeof(int) * 10);
free(ptr);
ptr = NULL;  // Set to NULL
// Now calling free(ptr) again is safe (no error, but unnecessary)

d) Wrong Pointer Type:

// ERROR
float f = 3.14;
int *ptr = &f;  // Wrong type! Undefined behavior
printf("%d", *ptr);

// CORRECT
float f = 3.14;
float *ptr = &f;  // Correct type
printf("%f", *ptr);

e) Pointer Arithmetic Errors:

// ERROR
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
ptr += 10;  // Out of bounds!
printf("%d", *ptr);  // Undefined behavior

// CORRECT
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;
if (ptr + 2 < arr + 5) {  // Check bounds
    printf("%d", *(ptr + 2));  // Safe access
}

5. Array Out of Bounds

Error Example:

// ERROR
int arr[5] = {1, 2, 3, 4, 5};
arr[10] = 100;  // Out of bounds! Undefined behavior
printf("%d", arr[-1]);  // Negative index! Error

// CORRECT
int arr[5] = {1, 2, 3, 4, 5};
int index = 10;
if (index >= 0 && index < 5) {  // Bounds checking
    arr[index] = 100;
} else {
    printf("Index out of bounds!\n");
}

String Array Bounds:

// ERROR
char str[5];
strcpy(str, "Hello World");  // Buffer overflow!

// CORRECT
char str[50];
strncpy(str, "Hello World", sizeof(str) - 1);
str[sizeof(str) - 1] = '\0';

// Or use safer alternative
char str[50];
snprintf(str, sizeof(str), "Hello World");

2D Array Bounds:

// ERROR
int matrix[3][3];
matrix[5][5] = 100;  // Out of bounds!

// CORRECT
int matrix[3][3];
int row = 5, col = 5;
if (row >= 0 && row < 3 && col >= 0 && col < 3) {
    matrix[row][col] = 100;
}

6. Incorrect scanf Usage

a) Missing & (Address Operator):

// ERROR
int num;
scanf("%d", num);  // Missing &! Undefined behavior

// CORRECT
int num;
scanf("%d", &num);  // Address operator required

b) Format Specifier Mismatch:

// ERROR
float f;
scanf("%d", &f);  // Wrong format specifier! Undefined behavior

// CORRECT
float f;
scanf("%f", &f);  // Correct format specifier

// For double
double d;
scanf("%lf", &d);  // Use %lf for double

c) Buffer Issues with Characters:

// ERROR - Newline character in buffer
int num;
char ch;
scanf("%d", &num);
scanf("%c", &ch);  // Reads newline from previous input!

// CORRECT - Add space before %c
int num;
char ch;
scanf("%d", &num);
scanf(" %c", &ch);  // Space consumes newline

d) String Input:

// ERROR
char str[10];
scanf("%s", &str);  // Don't use & with strings!

// CORRECT
char str[10];
scanf("%s", str);  // String name is already address

// Better - limit input length
scanf("%9s", str);  // Read max 9 characters (leave space for '\0')

e) Not Checking Return Value:

// ERROR - No validation
int num;
scanf("%d", &num);  // What if user enters non-integer?

// CORRECT - Check return value
int num;
if (scanf("%d", &num) == 1) {
    printf("Valid input: %d\n", num);
} else {
    printf("Invalid input!\n");
}

7. Logical Errors

a) Using = instead of ==:

// ERROR - Always true (assignment returns assigned value)
int x = 5;
if (x = 10) {  // Assigns 10 to x, always true!
    printf("x is 10\n");
}

// CORRECT
int x = 5;
if (x == 10) {  // Comparison operator
    printf("x is 10\n");
}

b) Off-by-One Errors:

// ERROR - Array index starts from 0, not 1
int arr[5] = {1, 2, 3, 4, 5};
for (int i = 1; i <= 5; i++) {  // Accesses arr[5] which is out of bounds
    printf("%d ", arr[i]);
}

// CORRECT
int arr[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {  // Correct: 0 to 4
    printf("%d ", arr[i]);
}

c) Infinite Loops:

// ERROR - Condition never becomes false
int i = 0;
while (i < 10) {
    printf("%d ", i);
    // Missing i++!
}

// CORRECT
int i = 0;
while (i < 10) {
    printf("%d ", i);
    i++;  // Increment counter
}

d) Operator Precedence Issues:

// ERROR - Wrong precedence
int result = 2 + 3 * 4;  // You might expect 20, but it's 14
// Because * has higher precedence than +

// CORRECT - Use parentheses for clarity
int result = (2 + 3) * 4;  // Now it's 20

8. Flowchart/Debugging Tips

Systematic Debugging Approach:

1. Understand the Error:
   • Read compiler error messages carefully
   • Check line numbers mentioned in errors
   • Understand what the error means
2. Isolate the Problem:
   • Comment out code sections to find the problem area
   • Test with simple input values
   • Check each function separately
3. Add Debug Output:

   // Add printf statements
   printf("DEBUG: Entering function\n");
   printf("DEBUG: Value of x = %d\n", x);
   printf("DEBUG: Value of ptr = %p\n", ptr);

4. Use Compiler Warnings:
   • Compile with: gcc -Wall -Wextra program.c
   • Fix all warnings (they often indicate problems)
5. Use Debugger:
   • GDB for Linux: gdb ./program
   • Set breakpoints and step through code
   • Inspect variable values at runtime

Common Debugging Tools:

• Compiler Flags: -Wall, -Wextra, -Werror, -g
• Valgrind: Memory leak detector
• GDB: GNU Debugger
• Static Analyzers: cppcheck, clang-analyzer

Prevention Tips:

• Always initialize variables
• Check pointers for NULL before use
• Validate array bounds before access
• Free dynamically allocated memory
• Use meaningful variable names
• Add comments for complex logic
• Test with boundary values