C Programming Common Compilation And Runtime Errors Complete Guide

 Last Update:2025-06-22T00:00:00     .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION.    7 mins read      Difficulty-Level: beginner

Understanding the Core Concepts of C Programming Common Compilation and Runtime Errors

C Programming Common Compilation and Runtime Errors

Compilation Errors

Compilation errors occur when the C compiler parses the source code and encounters syntax or structural issues that violate the C programming rules. These include:

  1. Syntax Errors:

    • Missing Semicolon: Common mistake; forgetting a semicolon at the end of a statement. 
      int a = 10  // Missing semicolon
    • Misplaced Braces: Extra or missing braces can lead to syntax errors. 
      if (x > 0) {
printf("Positive");
    • Typographical Errors: Misspelled keywords, functions, or variables. 
      intr a = 5; // 'intr' should be 'int'

  2. Semantic Errors:

    • Incorrect Function Calls: Calling functions with incorrect parameters. 
      printf("%d", "Hello"); // Should be a %s for string
    • Undeclared Variables: Using variables before declaration. 
      printf("%d", x); // x is not declared
int x = 5;
    • Mismatched Data Types: Operations between incompatible data types. 
      int a = 5;
double b = 20.5;
a = b; // Implicit truncation, may not be intentional

  3. Linkage Errors:

    • Undefined References: Calling a function or variable that isn't defined. 
      main() {
    foo(); // foo() is not defined anywhere
}
    • Multiple Definitions: Declaring or defining a variable/function more than once. 
      int global;
int global; // Redefinition error

Runtime Errors

Runtime errors occur during the execution of a program when the program encounters an unforeseen condition that it cannot handle properly. Common types include:

  1. Segmentation Faults:

    • Dereferencing Null Pointers: Accessing memory that doesn't exist. 
      int *ptr = NULL;
*ptr = 5; // Dereferencing a NULL pointer
    • Array Out of Bounds: Writing or reading beyond the allocated array memory. 
      int arr[5];
arr[10] = 0; // Accessing 11th element out of a 5-element array

  2. Integer Division by Zero:

    • Performing division of any number by zero. 
      int x = 5;
int y = 0;
int z = x / y; // Division by zero

  3. Buffer Overflows:

    • Writing more data to a buffer than it can hold. 
      char buf[10];
strcpy(buf, "This is a longer string"); // Buffer overflow

  4. Stack Overflow:

    • Exceeding stack memory by recursively calling a function without a proper exit condition.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement C Programming Common Compilation and Runtime Errors

Complete Examples, Step by Step for Beginners: C Programming Common Compilation and Runtime Errors

1. Forgot to use semicolon (;) at the end of a statement

Error:

error: expected ';' before '}' token

Code Example:

#include <stdio.h>

int main() {
    printf("Hello, World!")
    return 0;
}

Fix: Add the missing semicolon after the printf function.

#include <stdio.h>

int main() {
    printf("Hello, World!");  // Added semicolon here
    return 0;
}

2. Using undeclared variables

Error:

error: 'num' undeclared (first use in this function)

Code Example:

#include <stdio.h>

int main() {
    printf("The number is %d\n", num);
    return 0;
}

Fix: Declare the variable num before using it.

#include <stdio.h>

int main() {
    int num = 10;  // Declared the variable here
    printf("The number is %d\n", num);
    return 0;
}

3. Mismatch of format specifiers with argument types

Error:

warning: format '%d' expects argument of type 'int', but argument 2 has type 'double'

Code Example:

#include <stdio.h>

int main() {
    double num = 10.5;
    printf("The number is %d\n", num);  // Using %d for double type
    return 0;
}

Fix: Use the correct format specifier for the variable type.

#include <stdio.h>

int main() {
    double num = 10.5;
    printf("The number is %f\n", num);  // Changed %d to %f for double type
    return 0;
}

4. Missing return type in the main function

Error:

warning: return type of 'main' is not 'int'

Code Example:

#include <stdio.h>

void main() {  // No return type
    printf("Hello, World!\n");
}

Fix: Change the return type of main to int.

#include <stdio.h>

int main() {  // Changed return type to int
    printf("Hello, World!\n");
    return 0;  // Return an integer value
}

5. Array index out of bounds

Error: This can cause a runtime error (crash), but the compiler may not always warn about it.

Segmentation fault (core dumped)

Code Example:

#include <stdio.h>

int main() {
    int arr[3] = {1, 2, 3};
    arr[3] = 4;  // Out of bounds
    return 0;
}

Fix: Access elements within the bounds of the array.

#include <stdio.h>

int main() {
    int arr[3] = {1, 2, 3};
    arr[2] = 4;  // Corrected index to 2
    return 0;
}

6. Not providing a loop terminate condition

Error: This can cause an infinite loop, leading to a runtime error or program hang.

Code Example:

#include <stdio.h>

int main() {
    int i = 0;
    while (i < 10) {
        printf("The value of i is %d\n", i);
        // No increment operation
    }
    return 0;
}

Fix: Add an increment operation inside the loop.

#include <stdio.h>

int main() {
    int i = 0;
    while (i < 10) {
        printf("The value of i is %d\n", i);
        i++;  // Added increment operation
    }
    return 0;
}

7. Using the wrong type for input/output functions

Error:

warning: format '%c' expects argument of type 'char *', but argument 2 has type 'int *'

Code Example:

#include <stdio.h>

int main() {
    int ch;
    scanf("%c", &ch);
    printf("The character entered is %d\n", ch);  // Using %d for character type
    return 0;
}

Fix: Use the correct format specifier for the variable type.

Top 10 Interview Questions & Answers on C Programming Common Compilation and Runtime Errors

1. What is a “syntax error” in C, and how can you resolve it?

Answer: A syntax error occurs when the code does not adhere to the rules of the C language grammar (e.g., missing ;, unmatched parentheses). The compiler flags these during the compilation phase. To resolve them:

  • Carefully read the error message(s) provided by your compiler.
  • Check for matching pairs of brackets (), {}, and [].
  • Ensure semicolons ; are present after statements.

2. How do you fix the error: “undeclared identifier”?

Answer: This error indicates that a variable or function used in the code hasn’t been declared before its use. To fix it:

  • Declare the variable or function at the beginning of its scope.
  • Ensure any external functions are declared or included via headers (using #include).

3. What does a “segmentation fault” signify?

Answer: A segmentation fault typically occurs due to an invalid memory access. It could happen if you’re trying to dereference a null pointer, modify a read-only memory location, etc. To fix it:

  • Check all pointer usages for validity (they should be assigned a correct address before use).
  • Validate array indices to ensure they don’t exceed array bounds.
  • Use debugging tools like gdb to trace which line of your code caused the fault.

4. Why do I encounter a “stack overflow error”?

Answer: Stack overflow happens when the stack’s maximum limit is exceeded. This usually occurs due to deep recursion without a proper base case or local variables using too much space on the stack. Solutions include:

  • Converting recursive algorithms to iterative ones when possible.
  • Increasing the stack size if necessary (system dependent).
  • Optimizing functions to reduce excessive stack usage with better algorithm implementation.

5. How can you avoid the “undefined reference to [function]” when linking?

Answer: This error appears when the linker cannot find the definition for a referenced function. Possible fixes include:

  • Ensure the source file containing the function implementation is linked.
  • Correctly use libraries if the function is external (include corresponding -l flags during linking).
  • Check for typos in the function name (case-sensitive in C).

6. What’s the difference between "linker error" and "compiler error"?

Answer: Compiler errors occur during the compilation phase, often due to issues within individual source files such as syntax errors or undeclared identifiers. Linker errors emerge during the linking phase, mostly because the linker cannot find required symbols (functions/variables).

  • To solve compiler errors, check the specific line numbers mentioned.
  • To solve linker errors, ensure all source files and libraries needed are provided correctly to the linker.

7. How do you handle the “implicit int” warning in C?

Answer: This warning arises if a function is called without being properly declared before its usage and the compiler assumes the default return type to be int. To eliminate this warning:

  • Include the prototype of the function before its first call.
  • Use header files appropriately to declare functions.

8. What is an “array out-of-bounds” error, and why is it so dangerous?

Answer: An "array out-of-bounds" error occurs when your program tries to access elements of an array beyond its defined limits. While some compilers may warn about this, others might not. Accessing out-of-bounds can lead to undefined behavior, including corruption of adjacent memory data, leading to crashes later.

  • Avoid array out-of-bounds errors by ensuring indices fall within valid ranges.
  • Employ boundary checks within loops or other code accessing arrays.

9. How do you debug a “memory leak”?

Answer: Memory leaks result from dynamic memory allocation (malloc, calloc, realloc) without corresponding deallocation (free). To identify and fix memory leaks:

  • Review your memory allocations and free all allocated memory blocks when no longer needed.
  • Use memory profiling tools (like Valgrind) to detect and pinpoint leaked memory.
  • Ensure that malloc calls are paired with free calls.

10. What causes a “floating point exception”?

Answer: A floating point exception usually occurs due to an arithmetic operation involving floating point numbers that results in division by zero or an overflow (e.g., computing the sine of an extremely large value). To handle this:

  • Validate inputs to floating point operations.
  • Check for division by zero and handle it appropriately (e.g., return error values or use assertions).
  • Use libraries providing protection against floating point exceptions (system-specific).

You May Like This Related .NET Topic

📥 Download Code ▶️ Watch Online 📖 Read Description

Login to post a comment.