Errors in C Programming: Types, Causes, and Examples Explained

👤 Written by Sounetra Ghosal | 🔄 Last updated: September 28, 2026 | 📁 C

Learning the C language is an important step for many school and college students, but it often feels confusing at the beginning. A big reason is the error messages. "Errors in C programming" can look cryptic when you are new.

One small mistake in the code can stop the entire program, which can be frustrating and demotivating for beginners. But C programming errors are not signs of failure. They are part of the learning process.

Knowing why these errors occur helps students fix them faster and write better code over time. In this article, we will explain the different types of errors in C simply and practically, including the two problems students ask us about most: segmentation faults and the "uninitialized variable" warning. Every example was compiled with GCC 13 on Linux, so the messages you see are real.

TL;DR: Errors In C Programming

What are Errors in the C Program?

Errors in a C program occur when the programmer writes code that does not follow the rules of the C language, or asks the program to do something impossible while it runs. Every programming language, including C, understands only code written in its specific syntax and structure.

When the programmer writes code in an incorrect format, the compiler detects the mistake and generates an error. These error messages help the programmer identify where the problem occurred and what needs to be corrected in the code.

It is like a situation where you only know English and someone is talking to you in French. As you don't know French, you will not understand what they are saying.

The same thing goes for the compiler. The C compiler only knows a particular set of rules and grammar. Writing the code differently will cause an error.

Why Do Students Struggle With Errors In C Programming?

From our experience, most students struggle with errors in C not because they lack intelligence. The main reason is that C is a strict, rule-based language where even small mistakes are not tolerated.

Here are some more reasons why students struggle with errors in C programming.

• C programming requires exact syntax, and even a missing semicolon can cause an error.
• Error messages shown by the compiler are often difficult for beginners to understand.
• Students usually focus on writing code quickly rather than understanding how it works.
• Many learners copy code from books or the internet without learning the logic behind it.
• C compilers give fewer hints than newer languages, and many useful warnings stay hidden unless you turn them on with -Wall.

If we try to give a practical view of these confusions, the following code snippet can be formed. Let us go through it.

// Beginners expect C to forgive small syntax mistakes
int x = 10 // Missing semicolon breaks the entire program
int y = 20; // GCC reports the error on this line, not the line above

// Confusing compiler errors that don't clearly explain the mistake
printf("%d\n", x); // One missing ';' can cause extra errors further down
printf("%d\n", y); // Beginners struggle to trace the real issue

// Writing code fast without understanding execution flow
int result = x + y; // Student knows this works
printf("%d\n", result); // But may not understand how values are stored and added

// Copying code without understanding pointers and memory
int *ptr = &x; // Pointer syntax is copied from examples
printf("%d\n", *ptr); // Dereferencing works, but logic is unclear

// Ignoring warnings
scanf("%d", x); // Missing '&': GCC warns, but the code still compiles and then crashes
printf("%d\n", x); // Beginners often ignore the warning and run it anyway

C programming errors might look confusing at first, but by the end of this article, reading the error messages will feel much easier.

What are the Types of Errors in C?

In the C programming language, there are mainly four types of errors. These categories are based on when and why the mistake shows up. Let's make a list of those errors:

1. Compile Time Error
2. Run Time Error
3. Linker Error
4. Logical Error

On top of these, the compiler can also give you warnings. A warning does not stop the program from compiling, but it often points to a real bug. We cover the most common one, the uninitialized variable warning, later in this guide.

Let's go through each of the errors one by one in detail.

What are The Compile Time Errors in C?

As the title says, this type of error occurs when the code is compiling. This type of error is often called a syntax error, because in most cases the programmer has made a mistake in the structure of the code.

For example, they forget the closing brace (}), forget a semicolon, or write a loop header incorrectly.

Why Students Commonly Face Compile-Time Errors:

• Students forget to use semicolons at the end of statements.
• Students open brackets { } but forget to close them properly.
• Some keywords or function names, like printf, are misspelled in the code.
• Header files are missing or written incorrectly.

These errors must be fixed before the code can run. If they are present, the compiler will not produce a program at all.

// Declaring The Header File
#include <stdio.h>
// Calling main Function
int main()
{
    // Declaring The Variable
    int i;
    // For Loop Defect-Comma Instead of Semicolon
    for(i=0;i<10,i++)
    {
        // Simple Statement
        printf("Hello C Language");
    }
    return 0;
}

Steps Of The Program:

1. Declare the required header file inside the program before writing the main function.
2. Inside the main function, declare a for loop that contains the syntax error.
3. Inside that for loop, try to print any text.

Output:

compile.c: In function 'main':
compile.c:9:21: error: expected ';' before ')' token
    9 |     for(i=0;i<10,i++)
      |                     ^
      |                     ;

Here, the output clearly shows where we made the error: a comma was used instead of a semicolon in the for loop. Newer versions of GCC even print the fix, a ;, right under the spot where it belongs.

Understanding The Connection Between Compile-Time And Syntax Errors:

It is important to note that syntax errors are a subset of compile-time errors. Most compile-time errors come from syntax, but some come from meaning instead: using a variable that was never declared, or assigning a value to something that is not a variable. Here is one students write by accident:

// Declaring The Header File
#include <stdio.h>
// Calling main Function
int main()
{
    // Declaring The Variables
    int x, y, z;
    // Wrong Syntax For Assignment Operation
    x + y = z;
    return 0;
}

lvalue.c: In function 'main':
lvalue.c:9:11: error: lvalue required as left operand of assignment
    9 |     x + y = z;
      |           ^

The left side of = must be a place that can hold a value (an "lvalue"), like a variable. x + y is just a temporary result, so C cannot store anything in it. The correct form is z = x + y;.

• Whenever a compile-time error appears, first check the syntax, because most compile-time errors are caused by syntax issues.
• Always fix the first error and compile again. One missing semicolon can cause several "fake" errors on the lines after it.
• Many students get frustrated debugging compile-time errors without realizing that simple syntax mistakes are the cause.
• By paying careful attention to proper syntax while coding, you can prevent a large portion of compile-time errors before even running your program.

What are The Runtime Errors in C?

As the title says, this type of error occurs while the program is running. The code gets through compilation without a problem, but something goes wrong once it starts executing.

These errors pass the compile stage because the code is written correctly. The syntax is fine, but what the code asks the computer to do is not possible.

Why Students Commonly Face Runtime Errors:

• Division by zero is attempted without a proper check.
• Invalid memory access happens because of uninitialized or NULL pointers.
• Users type unexpected input values while the program runs.
• Array index limits are crossed without noticing.

Let's take an example where we try to divide a number by zero. The code is written correctly, so it compiles, but it fails when it runs.

// Declaring The Header File
#include <stdio.h>
// Calling main Function
int main()
{
    // Declaring The Variable
    int num = 5;
    // Run Time Error-Trying To Divide by Zero
    printf("result = %d", num/0);
    return 0;
}

Steps Of The Program:

1. Start the program by including the standard header file.
2. Declare one integer variable and give it a sample value.
3. Try to print the result of dividing that number by zero, which causes a runtime error.

Output:

runtime.c: In function 'main':
runtime.c:9:30: warning: division by zero [-Wdiv-by-zero]
    9 |     printf("result = %d", num/0);
      |                              ^

$ ./runtime
Floating point exception (core dumped)

In this case, GCC spots the problem and gives a warning at compile time, pointing to where we divide by zero. But it is only a warning, so the program still gets built. When we run it, it crashes with "Floating point exception." Despite the name, this crash comes from integer division by zero. Dividing a float or double by zero does not crash in C; it gives inf. In real assignments, the divisor usually comes from user input, so the compiler cannot warn you, and the program just crashes.

Segmentation Fault: The Most Common C Runtime Error

One of the most notorious runtime errors is the segmentation fault, or segfault. It happens when a program tries to read or write memory it is not allowed to touch. In C programming, every program gets certain areas of memory for its variables and data. If the program touches an address that is not mapped for it, the operating system stops it with a segmentation fault. Small overruns often go unnoticed, as you will see below. When you are working with pointers and arrays, this is very common.

Here is the simplest way to cause one:

#include <stdio.h>

int main()
{
    int *ptr = NULL; // A NULL Pointer Is Declared
    printf("Before Accessing The Pointer\n");

    *ptr = 10;  // The Segfault Will Happen Here
    printf("After Accessing The Pointer\n");
    return 0;
}

Output in the terminal:

Before Accessing The Pointer
Segmentation fault (core dumped)

The first message printed, but the second never did, so the crash happened somewhere between them: at *ptr = 10;. A NULL pointer does not point to any memory your program owns, so writing to it is illegal.

Common Causes Of A Segmentation Fault In C

• NULL pointer dereference: using *ptr when ptr is NULL, like the example above.
• Uninitialized pointers: a pointer that was declared but never given an address points to a random spot in memory.
• Out-of-bounds access: reading or writing past the end of an array.
• Missing & in scanf(): scanf("%d", x) treats the value of x as an address and writes to it. GCC warns about this one: format '%d' expects argument of type 'int *', but argument 2 has type 'int'.
• Using memory after free(): once memory is freed, the pointer still holds the old address, but the memory is no longer yours.
• Recursion with no base case: every call uses stack memory, and eventually the stack runs out.

How To Debug A Segmentation Fault In Your C Homework

Method 1: Use the GNU Debugger (GDB). GDB is a command-line tool that runs your program and shows the exact line where it crashed. Compile with -g so GDB can match the program to your source code:

gcc -g program.c -o program
gdb ./program
(gdb) run
(gdb) bt

Here is a real run on a small program where main() passes a NULL pointer to a function:

#include <stdio.h>

void setScore(int *score)
{
    *score = 95;
}

int main()
{
    int *score = NULL;
    setScore(score);
    printf("Score: %d\n", *score);
    return 0;
}

Program received signal SIGSEGV, Segmentation fault.
0x0000555555555159 in setScore (score=0x0) at gdbdemo.c:5
5           *score = 95;
(gdb) bt
#0  0x0000555555555159 in setScore (score=0x0) at gdbdemo.c:5
#1  0x0000555555555182 in main () at gdbdemo.c:11

The bt (backtrace) command shows that the crash was on line 5 inside setScore(), that score was 0x0 (NULL), and that main() called it from line 11. That is usually all you need to find the bug.

Method 2: Use print statements. If you cannot use GDB, add printf() lines to trace how far the program gets. If one message prints and the next one does not, the crash is between them, just like in the first example above.

One important catch: when output goes to a file or an autograder instead of your screen, C saves up printed text and writes it later. If the program crashes first, those messages are lost, and it looks like nothing ran. We tested this: with the output redirected to a file, even "Before Accessing The Pointer" never appeared. Print your debug messages to stderr instead, which is written right away: fprintf(stderr, "Reached step 2\n");. Or call fflush(stdout); after each printf().

Method 3: Check for NULL or uninitialized pointers. If you are working with pointers in your C homework, never leave a pointer uninitialized, and check pointers before you use them. malloc() returns NULL when it cannot get memory, so always check its result:

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

int main()
{
    int *ptr = malloc(sizeof(int)); // Asking For Memory For One int

    if (ptr == NULL) // Checking For A Null Pointer
    {
        printf("Memory Allocation Error\n");
        return 1;
    }

    *ptr = 23; // Assigning A Value Through The Pointer
    printf("Pointer Value: %d\n", *ptr);

    free(ptr); // Free The Memory
    ptr = NULL; // Reset The Pointer
    return 0;
}

Pointer Value: 23

Explanation Of The Program:

• First, malloc() asks for enough memory to hold one int, and ptr stores its address.
• The if statement checks whether malloc() returned NULL. If it did, the program prints a message and ends safely instead of crashing.
• If the pointer is not NULL, we store a value through it and print it.
• Finally, free() gives the memory back, and we set ptr to NULL, so an accidental use crashes right away instead of quietly reading freed memory.

If malloc() and free() are still new to you, our guide to dynamic memory allocation in C explains how they work.

Method 4: Check your array access. Arrays are the other big cause of memory errors. C does not check array bounds for you, so you have to make sure every index stays inside the array:

#include <stdio.h>

int main()
{
    int arr[5]; // The Array Can Only Store 5 Items

    for (int i = 0; i <= 7; i++)  // The Loop Goes Past The Last Index (4)
    {
        arr[i] = i * 10;
    }
    printf("Loop finished\n");
    return 0;
}

Output in the terminal:

Loop finished
*** stack smashing detected ***: terminated
Aborted (core dumped)

The array has room for 5 items (indexes 0 to 4), but the loop writes all the way up to index 7. Notice that we did not get a segmentation fault this time. The loop finished, and the stack protection that Ubuntu's GCC turns on by default caught the damage as main() ended. That is what makes out-of-bounds bugs so tricky. Depending on the compiler and the machine, the same mistake can cause a segfault, a "stack smashing" abort, a changed value in some other variable, or no visible problem at all. The fix is to stop the loop at the real size of the array:

#include <stdio.h>

int main()
{
    int arr[5];
    int size = sizeof(arr) / sizeof(arr[0]); // 5

    for (int i = 0; i < size; i++)  // Stops At Index 4
    {
        arr[i] = i * 10;
    }
    printf("Last value: %d\n", arr[size - 1]);
    return 0;
}

Last value: 40

Method 5: Use AddressSanitizer. Modern GCC and Clang can catch out-of-bounds and use-after-free accesses while the program runs. Compile with -fsanitize=address -g and run the program. On the out-of-bounds example above, it stopped at the exact bad write and named the line: stack-buffer-overflow ... in main array.c:9. It catches use-after-free bugs too.

How To Prevent Segmentation Faults In C Homework

• Always initialize pointers, either to a valid address or to NULL.
• Never access an array beyond its size in a for loop. Use i < size, not i <= size.
• Check what malloc() returns before using the memory.
• After free(ptr), set ptr = NULL.
• Give every recursive function a base case that stops the recursion.
• In scanf(), pass addresses with & for numbers, and limit string input with a width, like scanf("%19s", name) for a 20-character array.
• Compile with -Wall. GCC warns about a missing & in scanf(), using a pointer after free(), and infinite recursion.

If you also write C++, our guide to common C++ errors covers segfaults along with C++ problems like uncaught exceptions, plus double free, which happens in C too. And if a segfault in your C homework still will not go away, our C homework help experts can walk through the code with you.

What are The Linker Errors in C?

This type of error happens during linking, the step that comes right after compilation. The compiler turns each .c file into an object file. Then the linker combines those object files with the libraries your code uses (like the one that contains printf()) to build the final program. If the linker cannot find something your code needs, you get a linker error.

Why Students Commonly Face Linker Errors:

• The main function is misspelled or missing.
• A required library is not linked. For example, math functions like sqrt() need -lm when you compile with GCC on Linux.
• A function is called, but no file in the build defines a function with that exact name.
• A second .c file is not included in the compile command.

Let's take an example where the main function is written the wrong way, which causes a linker error.

// Declaring The Header File
#include <stdio.h>

void mainn() // Calling Wrong main Function
{
    // Simple Statement
    printf("Hello C Program");
}

Steps Of The Program:

1. The standard stdio.h header file is included.
2. We write mainn() instead of main(), which is the mistake.
3. We put a simple statement inside it, but it will never run.

Output:

/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x1b): undefined reference to `main'
collect2: error: ld returned 1 exit status

Notice that there is no line number this time. The file compiled fine. The problem was found by the linker (ld), which could not find a function named main to start the program with. The key words to look for are "undefined reference to," followed by the name of whatever is missing.

What are The Logical Errors in C?

This type of error occurs when the logic of the program is wrong. The syntax is correct, linking works, and the program runs to the end. But the output is not what you expected, and there is no error message to tell you something is off.

Why Students Commonly Face Logical Errors:

• Students misunderstand the problem statement.
• Incorrect formulas or conditions are written in the program.
• Variables are used wrongly in calculations.
• Loop conditions are written incorrectly, so a loop runs one time too many or too few.

Here is a classic example. The program should print the average of 7 and 8, which is 7.5:

#include <stdio.h>

int main()
{
    int a = 7, b = 8;
    float average = (a + b) / 2;   // integer division happens first

    printf("Average = %.2f\n", average);
    return 0;
}

Output:

Average = 7.00

There is no error and no warning, but the answer is wrong. (a + b) / 2 divides one int by another int, so C does integer division and throws away the .5 before the result is ever stored in the float. Making one side a decimal fixes it:

#include <stdio.h>

int main()
{
    int a = 7, b = 8;
    float average = (a + b) / 2.0f;   // 2.0f forces decimal division

    printf("Average = %.2f\n", average);
    return 0;
}

Average = 7.50

The best way to catch logical errors is to test your program with inputs where you already know the correct answer, then trace the code with printf() or GDB to see where the values go wrong.

The "Uninitialized Variable" Warning In C

When you are solving your C homework, your code might compile but behave strangely, printing a random number where you expected a real value. This is usually caused by an uninitialized variable, and if you compile with warnings turned on, GCC tells you about it.

In C programming, writing a variable's name with its data type (int marks;) is called declaration. Giving it a value (marks = 90;) is called initialization. A local variable that is declared but not initialized holds whatever leftover data was already in that memory, often called a garbage value. If you use the variable before giving it a value, you are using an uninitialized variable.

This is a warning, not an error. The compiler still builds your program, which is exactly why students miss it. And with a plain gcc program.c, GCC does not show this warning at all. You only see it when you compile with -Wall:

gcc -Wall program.c -o program

What Can Happen When You Use An Uninitialized Variable

• The program prints a garbage value, and it can be a different number every time you run it.
• Calculations that use the variable give wrong answers, and the mistake spreads to everything that depends on them.
• If the variable is a pointer, using it can crash the program with a segmentation fault.
• The bug is hard to find, because the program might even work on your computer and then fail on your instructor's.
• In real software, reading uninitialized memory can leak leftover data, which is a security risk.

Why Does The "Uninitialized Variable" Warning Occur?

1. Using variables before assigning a value. This is the most common cause in C homework. The variable is declared, then used right away:

#include <stdio.h>

int main()
{
    int zap; // Variable Declaration
    printf("The Value: %d\n", zap);  // The 'zap' Is Uninitialized
    return 0;
}

uninit1.c: In function 'main':
uninit1.c:6:5: warning: 'zap' is used uninitialized [-Wuninitialized]

$ ./uninit1
The Value: 32764

Here, zap is declared but never given a value, so it holds a garbage value. When we ran it, it printed 32764. On your machine it may print something completely different.

2. Skipping the assignment in a conditional statement. Sometimes a variable only gets a value inside an if block. When the condition is false, the variable is left uninitialized:

#include <stdio.h>

int main()
{
    int marks;
    int flag = 0;

    if (flag) // If 'flag' Is Non-Zero (True)
        marks = 90; // Marks Will Be Initialized

    // If 'flag' Is 0 (False), Marks Stays Uninitialized
    printf("Garbage Value Of Marks: %d\n", marks);
    return 0;
}

Garbage Value Of Marks: -992233640

Here, flag is 0, which C treats as false, so the if block does not run and marks never gets a value. The program printed a garbage number.

Here is the surprising part. With plain -Wall, GCC 13 gave no warning for this code. It only warned when we also turned on optimization with -O2. And when flag came from scanf() instead, GCC gave no uninitialized-variable warning, even with -Wall -O2. The compiler cannot catch every case, so do not rely on the warning alone. Initialize your variables.

3. Returning uninitialized values from functions. If a function returns a variable that was never given a value, the caller receives a garbage value:

#include <stdio.h>

int Zap()
{
    int x;
    return x;  // Returning Uninitialized Variable
}

int main()
{
    printf("The Function Value: %d\n", Zap());
    return 0;
}

uninit3.c: In function 'Zap':
uninit3.c:6:12: warning: 'x' is used uninitialized [-Wuninitialized]

$ ./uninit3
The Function Value: 32554

How To Fix The "Uninitialized Variable" Warning In C Homework

1. Always initialize every variable. Whenever you declare a variable, give it a starting value on the same line, such as 0 for numbers or NULL for pointers. This also works for arrays and structures:

#include <stdio.h>

struct Student {
    int id;
    float gpa;
};

int main()
{
    int zap = 0;             // Integer Initialization
    float one = 0.0f;        // Float Initialization
    char code = 'A';         // Character Initialization
    char *coding = NULL;     // Pointer Initialization
    int scores[5] = {0};     // Every Element Of The Array Becomes 0
    struct Student s = {0};  // Every Member Of The Structure Becomes 0

    printf("%d %.1f %c %p %d %d %.1f\n", zap, one, code, (void *)coding, scores[4], s.id, s.gpa);
    return 0;
}

0 0.0 A (nil) 0 0 0.0

Here, the integer, float, character, pointer, array, and structure are all declared and initialized, so none of them can hold garbage. = {0} sets every element of an array, or every member of a structure, to zero.

2. Initialize the return value. Before a function returns a variable, make sure the variable has a real value. The simplest way is to declare and initialize it on the same line:

#include <stdio.h>

int Zap()
{
    int x = 1021; // Declared And Initialized Together
    return x;     // Returning Initialized Variable
}

int main()
{
    printf("The Function Value: %d\n", Zap());
    return 0;
}

The Function Value: 1021

3. Use default values in conditional blocks. If a variable only gets a value inside an if, give it a default value first. Zero is usually a safe default:

#include <stdio.h>

int main()
{
    int marks = 0; // Default Value
    int flag = 0;

    if (flag) // If 'flag' Is Non-Zero (True)
        marks = 90;

    // If 'flag' Is 0, The Default Value Is Used
    printf("Default Value Of Marks: %d\n", marks);
    return 0;
}

Default Value Of Marks: 0

Now, if the if block does not run, marks still has a known value, and the warning goes away.

Good to know: global variables and static variables are automatically set to 0 in C. Only local variables inside functions start with garbage. That is why a variable can "work" when it is global and suddenly break when you move it inside main().

Real Example: Fixing The Uninitialized Variable Warning

Problem Statement: Write a C program to add two integers and print the result.

Wrong Code: Here is the incorrect version, which triggers the warning.

#include <stdio.h>

int main()
{
    int a, b, sum; // Variables Are Declared, Not Initialized
    sum = a + b;   // Adding Two Uninitialized Values

    printf("The Result: %d\n", sum); // Printing The Garbage 'sum'
    return 0;
}

sum_wrong.c: In function 'main':
sum_wrong.c:6:9: warning: 'a' is used uninitialized [-Wuninitialized]
sum_wrong.c:6:9: warning: 'b' is used uninitialized [-Wuninitialized]

$ ./sum_wrong
The Result: 1496555030

All three variables are declared, but a and b never get values, so the sum is garbage plus garbage.

Correct Code: Every variable starts at 0, and a and b get their real values from the user before the addition:

#include <stdio.h>

int main()
{
    int a = 0, b = 0, sum = 0; // Every Variable Starts At 0

    printf("Enter two numbers: ");
    scanf("%d %d", &a, &b);    // Now a and b hold real values
    sum = a + b;

    printf("The Result: %d\n", sum);
    return 0;
}

Enter two numbers: 3 4
The Result: 7

Key Takeaways:

• Declaring a variable and initializing it are two different steps in C.
• The uninitialized variable warning appears when you use a local variable before giving it a value. Compile with -Wall to see it.
• Common causes include using a variable right after declaring it, assigning it only inside an if, and returning an uninitialized value from a function.
• The fix is simple: initialize every variable, array, structure, and return value when you declare it.

Comparison Table Between Different Errors In C Programming

After understanding all the different types of errors in detail, here's a concise comparison to help you quickly identify and tell apart compile-time, runtime, linker, and logical errors.

How To Identify Which Error You Are Getting In Your C Programming Task?

If you are still confused about which error you are getting in your C program, this short table will help. It is based on how the program behaves.

Which Error Is Most Dangerous for Students? And Why

We have helped students with C programming for many years, and we have seen that not every error is equally risky. There is one type that trips up most students, especially in exams and autograded assignments.

In our view, that is the logical error. Here is why logical errors are risky during exams.

• The main risk is that students assume the code is correct because it compiles successfully.
• The program runs without showing any error messages, which gives the student false confidence.
• Wrong logic leads to incorrect output and fails autograder tests, resulting in a loss of marks.
• Logical mistakes are harder to detect than syntax errors, especially for a beginner.
• To debug a logical error, students need a solid understanding of the problem itself.

Understanding logical errors early helps students think more clearly, improve problem-solving skills, and become confident programmers.

Programming Task: Identify And Fix The C Language Error

We have seen many times that, despite knowing about all the errors in C, students still get stuck in lab exams because they are not familiar with the question patterns.

To help you feel comfortable and confident during lab exams, let's go through a real programming task where you need to find and fix the error in a C program.

Question: The following program takes two numbers from the user and divides them. The program compiles successfully but crashes during execution. Identify the error and modify the program to prevent the crash.

Incorrect Code:

#include <stdio.h>
int main()
{
    int a, b;
    // Read Two Integer Values From User
    printf("Enter Two Numbers: ");
    scanf("%d %d", &a, &b);

    // Perform Division And Display The Result
    printf("Result: %d\n", a / b);
    return 0;
}

The program does not check whether the second number (b) is zero before dividing. If the user enters zero, the program crashes at runtime.

This is a common student mistake because beginners focus on syntax and forget about invalid user input.

Error Output:

Enter Two Numbers: 10 0
Floating point exception (core dumped)

Correct Code:

#include <stdio.h>
int main()
{
    int a, b;
    // Read Two Integer Values From User
    printf("Enter Two Numbers: ");
    scanf("%d %d", &a, &b);

    // Check Whether The Divisor Is Zero Before Division
    if (b == 0)
        printf("Error: Division By Zero Is Not Allowed.\n");
    else
        // Perform Division Only When It Is Safe
        printf("Result = %d\n", a / b);
    return 0;
}

This is a runtime error because the division by zero happens while the program is running. The code compiles correctly, but the program crashes during execution.

A condition was added to check whether the divisor is zero before performing the division. This prevents the crash and makes the program safe. It shows how important input validation is in real-world programming.

Correct Output:

Enter Two Numbers: 10 0
Error: Division By Zero Is Not Allowed.

Enter Two Numbers: 10 2
Result = 5

Conclusion

"Errors in C programming" are one of the best teachers you will have. Every error message tells you something about how C works.

As programs grow larger and more complex, identifying and fixing errors becomes even more important. By carefully reading compiler messages, turning on warnings with -Wall, and understanding what causes each error, you can write more reliable C programs.

Knowing the error type is only half the job; fixing it correctly matters even more. These tips for debugging common coding errors come from real failed submissions and will help you develop a calmer, step-by-step approach when your code doesn't work as expected.

Key Takeaways:

• Understanding the different types of errors in C helps you debug programs faster and with more confidence.
• Compile-time errors occur before execution and are most commonly caused by syntax-related mistakes in the code.
• Runtime errors appear while the program is running and may crash the program or produce unexpected behavior. Segmentation faults are the most common one.
• Linker errors happen after compilation, when required functions, files, or libraries are missing or not properly connected.
• Logical errors are the hardest to detect because the program runs successfully but produces incorrect output.
• Always compile with -Wall, and initialize every variable when you declare it.

Frequently Asked Questions

1. Can a program have multiple types of errors at once?

Yes, a program can have multiple types of errors at the same time. For example, it may contain syntax errors, logical mistakes, and runtime issues all at once. You will only see them one stage at a time, though: the compiler reports syntax errors first, and runtime and logical errors only show up once the program builds.

2. Why does my C program compile but not give the correct output?

If your C program compiles successfully but produces incorrect output, it usually means there is a logical error. The instructions are correct C, but the logic or order of operations is flawed. Another common cause is an uninitialized variable, so compile with -Wall and check for warnings.

3. Are runtime errors always visible?

No. Some runtime errors, like division by zero or accessing a NULL pointer, usually crash the program right away. Others, like reading an uninitialized variable or writing one element past the end of an array, may not crash at all. They can quietly change other values or give wrong results, which makes them much harder to find.

4. What causes a segmentation fault in C?

A segmentation fault happens when your program touches memory it does not own. The most common causes are using a NULL or uninitialized pointer, going past the end of an array, forgetting the & in scanf(), using memory after free(), and recursion with no base case.

5. How do I find the line that causes a segmentation fault?

Compile with gcc -g program.c -o program, run it with gdb ./program, type run, and then type bt after it crashes. GDB shows the file, the function, and the exact line. You can also compile with -fsanitize=address to get a detailed report.

6. Why do I not see the uninitialized variable warning?

GCC does not show it by default. Compile with -Wall to turn it on. Even then, GCC misses some cases, such as a variable that is only set inside an if block, so the safest habit is to initialize every variable when you declare it.

7. Is "undefined reference to main" a compile error or a linker error?

It is a linker error. Your code compiled, but the linker could not find a function named exactly main. Check that main is spelled correctly in lowercase, that the file is saved, and that you are compiling the file that contains main().