Types Of Errors In C And How To Handle Them (Explained With Examples)

Errors are an inevitable part of the programming process, and this naturally applies to the C language as well. As one of the most popular programming languages, C provides a vast array of functionalities and flexibility, but it also demands careful attention to detail. Understanding the different types of errors that can occur in C programming is crucial for writing efficient, bug-free code.

In this piece of article, we'll look at the various types of errors in C programming language, i.e., syntax errors, logic errors, and runtime errors. We will give a detailed description of each type of error's characteristics and also discuss error handling in C with the help of examples.

How To Read An Error In C?

• Check the line number and filename of the error: The first step to understanding an error message in C is to check for any line numbers or filenames that may be included in the message. This will help you determine which part of your code is causing issues so that you can address it directly.
• Look up syntax errors: Syntax errors generally occur when something has been typed incorrectly, such as a missing semi-colon or incorrect variable types being assigned during an operation. If you spot these types of mistakes quickly, they are usually effortless to fix!

• Examine warnings carefully: Warnings indicate that while something may not be wrong with your code immediately, it could cause problems later on if left uncorrected — so take them seriously! Most commonly, this relates to potential memory leaks, unused variables/functions, etc., but make sure no unexpected behavior stemming from overlooked warnings can appear at runtime before continuing development work on a project.
• Know where else to turn: In most cases debugging yourself should suffice when dealing with any type of error in C programs. However, remember that there are plenty of other sources available online (including tutorials here!) if feeling stuck or confused by specific nuances within its syntax understandably proves to be a challenge.

Types Of Errors In C Programming

The various types of errors in C can be broadly classified into five types, namely- syntax, run-time, linker, logical, and semantic. We have discussed these in proper detail ahead.

Syntax Error In C

When a programmer writes code that does not follow the C syntax rules, it leads to the creation of syntax errors. In other words, this type of error occurs when there are typos, missing keywords or variables, mismatched parentheses, and brackets, incorrect data types used for operations in a program, etc.

Syntax errors can cause a program to either crash or produce unexpected results as it cannot understand what instructions have been given by the programmer. This is because computers need precise instructions in a language that conforms strictly to their understanding of programming logic. Thus, any mistakes made in terms of the language/ syntax will create an error message.

Types of Syntax Errors

The most common types of syntax errors in C are-

1. Missing semicolon at the end of a statement
2. Unclosed parentheses, brackets, or curly braces
3. Mismatched data types for operators and operands
4. Misspelling in keywords/identifiers
5. Using undeclared variables

The syntax errors are also known as compilation errors. This is because these errors only become known when the compiler is compiling the code. That is when code is compiled, it means that the compiler goes through each line of the program and checks for any syntax errors. If it finds an error, then compilation will not be successful due to a syntax or compilation error. 

Example Of Syntax Error In C

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpIHsKCnByaW50ZigiSGVsbG8gVW5zdG9wIikKCnJldHVybiAwOwoKfQ==

Output error:

6 | printf("Hello Unstop")
| ^
| ;
7 |
8 | return 0;

Explanation:

In the program above, there is no semicolon after the printf statement, which causes an error. The semicolon is required to terminate every statement in C, and this is one of the most common types of syntax errors.

The correct code for the same example is-

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpIHsKCnByaW50ZigiSGVsbG8gVW5zdG9wIik7CgpyZXR1cm4gMDsKCn0=

Output:

Hello Unstop

Runtime Error In C

A runtime error occurs when a code is executed and an unexpected condition happens. The most common causes of these errors are- coding mistakes, memory corruption, or incorrect system configuration. In C, they also occur because of programming language bugs, memory leaks due to a lack of proper clean-up code after executing a function (especially dynamic allocations), and bugs in user input parameters, which can have dangerous repercussions like segmentation fault and buffer overflow problems.

Types of Runtime Errors

The most common types of runtime error in C are:

1. Compiler Errors: These errors indicate that the code doesn't compile or build properly due to invalid syntax, typos, and other issues with your program source code. It is also known as compile time error.
2. Logical Errors: These errors occur when you write correctly formatted but incorrect logic in your program, like using an uninitialized variable or trying to access memory beyond what has been allocated for a pointer.
3. Memory Errors: These are related to improper use of dynamic memory allocation functions such as malloc(), calloc() etc., which can result in a buffer overflow and segmentation violation errors, causing the application to crash unpredictably at runtime.

A runtime error is also called an exception. An exception occurs when the program encounters a situation that it isn't designed to handle and needs special handling, such as an attempt to divide by zero or access memory outside its allocated space. When this kind of unexpected behavior happens during execution, the C runtime library throws an exception which can be handled in user-defined ways like printing out error messages.

Example of Runtime Error In C

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpCgp7CgppbnQgYSA9IDEwLCBiID0gMDsKCmludCByZXN1bHQgPSBhL2I7CgpwcmludGYoIlJlc3VsdCBpczogJWQgXG4iOywgcmVzdWx0KTsKCnJldHVybiAwOwoKfQ==

Output error:

9 | printf("Result is: %d \n";, result); // Print out the value of 'result' variable
| ~ ^
| )
9 | printf("Result is: %d \n";, result); // Print out the value of 'result' variable
| ~^
| |
| int

Explanation:

The error in this code is that a division by zero is attempted, which cannot be done. This causes a run-time error that results in the program crashing.

The correct code is:

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpCgp7CgppbnQgYSA9IDEwLCBiID0gMTA7CgppbnQgcmVzdWx0ID0gYS9iOwoKcHJpbnRmKCJSZXN1bHQgaXM6ICVkIFxuIiwgcmVzdWx0KTsKCnJldHVybiAwOwoKfQ==

Output:

Result is: 1

Check this out- Boosting Career Opportunities For Engineers Through E-School Competitions

Logical Error In C

A logical error in C is an error that occurs when a program produces an incorrect output as a result of incorrect logic or incorrect input.

For example, if a user were to input two numbers into a program expecting the sum of those two numbers to be returned. But instead of that, the product was returned due to flawed logic in the code; then this would be considered a logical error. Logical errors occur when commands are written incorrectly and the computer does not understand them, for example, writing “printf” instead of “printf().”

Example Of Logical Error In C

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpCgp7CgppbnQgeCA9IDI1OwoKaW50IHkgPSA0NTsKCnByaW50ZigiVGhlIHN1bSBvZiB4IGFuZCB5IDogJWQiLHgqeSk7CgpyZXR1cm4gMDsKCn0=

Output error:

The sum of x and y: 1125

Explanation:

The error in the code is that it incorrectly calculates the sum of x and y, instead of multiplying them. The printf statement should have read "printf("The sum of x and y : %d",x+y);" to correctly calculate the sum. correct the code

The correct code is:

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpCgp7CgppbnQgeCA9IDI1OwoKaW50IHkgPSA0NTsKCnByaW50ZigiVGhlIHN1bSBvZiB4IGFuZCB5IDogJWQiLHgreSk7CgpyZXR1cm4gMDsKCn0=

Output:

The sum of x and y: 70

Semantic Error In C

A semantic error in C is a type of programming error that occurs when a programmer uses valid syntax, but the code does not produce the intended result. It typically results from misunderstanding language rules and making assumptions about how code works.

Types Of Semantic Errors

Some of the most commonly occurring semantic errors are:

1. Typo errors arise when a programmer mistypes a keyword, such as mixing up the spelling of "if" and "of." These errors can be difficult to decode because there is no indication that something is wrong from the compiler's perspective, but it will still cause issues with program execution.
2. Unresolved symbols typically happen due to incomplete library imports or undeclared variables used within the code. When this happens, the compiler does not recognize their existence and thus cannot generate object code for them in time for successful compilation/execution. Additionally, it may result in linker errors if unresolved references are found during the linking stages of compiling programs as well.
3. Mismatched type conversions involve assigning an int value to a char variable without casting first.
4. Dereferencing NULL pointers occurs when trying to access memory locations whose address has been assigned as 0 - often resulting in segmentation faults.
5. Incomplete function calls involve providing too few argument lists on function calls with multiple parameters. This, again, will lead to linker errors or undefined behavior at runtime if executed successfully.
6. Logical errors happen when incorrect comparison operators are used, such as using '==' instead of '=' or having an erroneous loop condition resulting in an infinite loop.
7. Forgetting to use braces is also another standard semantic error where programmers fail to specify start/end boundaries for any given block causing unexpected behavior at run time.
8. Unused variables are those declared in code but not referenced anywhere, which can lead to confusion and potentially cause issues if they're later changed unconsciously from their original values due to inconsistencies within the codebase itself.

Note: Semantic errors are similar to syntax errors in C because they produce unexpected results when attempting to execute a program. However, semantic errors are not related to the grammar or structure of the code. Instead, they refer to mistakes made within the logic of a program that can cause incorrect output despite valid syntax.

Syntax errors will generate an error message from the compiler telling you what line is invalid and, typically, why it's weak. In contrast, semantic errors generally do not indicate their presence or exact nature except for producing incorrectly calculated results.

Example of Semantic Error In C

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbih2b2lkKQoKewoKaW50IHggPSAxNTsKCnByaW50ZigiJXMiLCB4KTsKCnJldHVybiAwOwoKfQ==

Output error:

Segmentation fault

Explanation:

This is a specific kind of semantic mistake because the syntax employed here is correct but only results in the intended result. This line of code will not provide any useful results since the printf() function requires a string rather than an integer.

The correct code is:

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbih2b2lkKQoKewoKaW50IHggPSAxNTsKCnByaW50ZigiJWQiLCB4KTsKCnJldHVybiAwOwoKfQ==

Output:

15

Linker Error In C 

Linker errors happen when the linker cannot find the libraries or object code necessary to create a running executable. This can happen either due to the wrong function prototyping or the usage of the wrong header file. They usually indicate a problem with missing or incompatible libraries.

Linker errors often occur in C when there are typos in #include statements, incorrect library paths, mismatched function definitions, and undeclared functions. Linker errors also arise when coders forget to specify certain compiler flags or use incorrect flag values for compiling source code files.

Example of Linker Error In C

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgYWRkKGludCB4LCBpbnQgeSkKCnsKCnJldHVybiB4K3k7Cgp9CgppbnQgbWFpbigpCgp7CgppbnQgYSA9IDMwLCBiID0gMjU7CgpwcmludGYoIlN1bSBvZiAlZCBhbmQgJWQgaXMgOiVpXG4iLGEsYiAsYWRkKGEsYikpOwoKcmV0dXJuIDAgOwoKfQ==

Output error:

5 | printf("Sum of %d and %d is:%d", a, b);
| ~^
| int
6 | printf("Sum of %d and %d is :%i\n",a,b ,add(x,y));
| ^~~
/tmp/RXJAFpp7Rw.c:6:49: error: 'x' undeclared (first use in this function)
6 | printf("Sum of %d and %d is :%i\n",a,b ,add(x,y));
| ^
note: each undeclared identifier is reported only once for each function it appears in
error: 'y' undeclared (first use in this function)
6 | printf("Sum of %d and %d is :%i\n",a,b ,add(x,y));
| ^

Explanation:

The error states that the function definition of add is missing from the program. Additionally, variables a and b are not declared in the program, and the return statement for main() is also missing. Also note that the printf statement should use the return value of add separated by a comma (",").

The correct code is:

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgYWRkKGludCB4LCBpbnQgeSkKCnsKCnJldHVybiB4K3k7Cgp9CgppbnQgbWFpbigpCgp7CgppbnQgYSA9IDMwLCBiID0gMjU7CgpwcmludGYoIlN1bSBvZiAlZCBhbmQgJWQgaXMgOiVpXG4iLGEsYiAsYWRkKGEsYikpOwoKcmV0dXJuIDAgOwoKfQ==

Output:

Sum of 30 and 25 is :55

Also read- 100+ Top C Interview Questions With Answers (2023)

Error Handling In C Programming

Error handling is an important aspect of programming. This is because proper error handling allows programs to gracefully handle unexpected situations. Also, unchecked errors during compilation time provide meaningful feedback to users and prevent crashes or incorrect behavior. Error handling in C primarily involves the use of return values or modifying the global Errno variable.

When a function encounters an error that it cannot handle, it may set the value of errno and then go ahead and return from its execution flow with a special code like -1 to indicate to the calling application that something went wrong during execution. The application can check for this code upon function invocation completion to determine whether or not any errors occurred during execution. If an error did occur, the value of Errno would provide additional details about what kind of problem was encountered so that appropriate steps could be taken to address it further.

Additionally, various library functions, such as perror(), are available, which allow applications easy access to figuring out detailed descriptions of particular kinds of errors based on their corresponding numbers stored within Errno's numerical representation system.

What Is Errno?

Errno values in C are integers containing values representing errors returned by library functions and system calls. It is defined as part of the standard header file <errno.h> and can be accessed through the global variable errno. Errno has different error codes for different types of errors, such as 0 (indicates success), ENOENT (No such file or directory), etc., which helps programmers to debug their C programs quickly.

Different Types of Erno Messages

The different types of erno error messages in C:

1. Syntax Errors - These errors occur when the programmer attempts to execute a program code that does not adhere to the syntax rules of C language.
2. Linker Error - This occurs when there is an error in linking object files or library modules during program compilation and execution.
3. Runtime Error - An erroneous situation that occurs at runtime due to wrong input, broken hardware components, etc., instead of programming logic errors, is known as a runtime error.
4. Logical Errors – These refer to incorrect algorithm implementation by a programmer, resulting in unwanted output even with correct inputs supplied for processing.
5. Compiler Warning – These warnings usually result from non-standard coding practices, lack of proper comments & uninitialized variables declaration while compiling a source file into machine executable form (object) at the time of compilation.
6. Preprocessor Error - These errors occur when the #include directive is misused or a referenced header file cannot be found in its proper location.

Methods Of Error Handling In C

Let's explore some common methods for error handling in C:

1. Return Values: Return values are straightforward, and one of the most widely used methods for error handling in C. Functions can return a specific value or an error code to indicate success or failure. The calling code can then check the return value to determine if an error occurred. By convention, a return value of 0 often indicates success, while non-zero values represent different error conditions. This method allows for simple and explicit error checking at the caller's end.

2. Global Error Variables: Global variables can be used to store error information. A global error variable is set when an error occurs, and the calling code can check the value of the error variable to determine if an error occurred. This method can be useful when multiple functions need to communicate errors. But this method should be used with caution as it can introduce complexity and potential issues in multi-threaded or concurrent programs.

3. Error Codes and Enumerations: Using error codes or enumerations is another common approach. Here, it becomes easier to identify and handle different types of errors by defining a set of meaningful error codes. Enumerations provide a way to organize and manage error codes in a more structured manner. Functions can return or accept error codes as parameters to communicate errors. This method is often used in conjunction with return values.

4. Error Handling Functions: Error handling functions encapsulate the logic for reporting or handling errors. They can be designed to accept error codes or additional error-specific information to provide more context about the error. Error handling functions can also perform actions like printing error messages, logging errors, freeing resources, or taking recovery steps. This method helps centralize error handling and improves code readability.

5. Exception Handling with setjmp/ longjmp: Although C does not have any built-in exception handling like some other languages. The setjmp and longjmp functions can be used to implement a form of exception handling in C. The setjmp function saves the current execution state, and the longjmp function jumps back to that state. This technique can be useful in certain scenarios where complex error recovery is required. However, it should be used carefully as it can make code harder to understand and maintain.

6. Error Reporting and Logging: Proper error reporting is crucial for effective error handling. Functions can use the standard output (printf), standard error (fprintf(stderr)), or logging mechanisms to report errors. Providing meaningful error messages helps users and developers understand what went wrong and how to resolve the respective error. Logging can also be used to record error information, including timestamps, function names, and contextual data, for debugging and troubleshooting purposes.

7. Resource Cleanup: Error handling should include proper resource cleanup to prevent memory leaks or resource exhaustion. So, when an error occurs, appropriate cleanup actions should be performed, such as freeing allocated memory, closing file handles, or releasing acquired resources. In addition, techniques like the Goto statement can also be used to jump to a cleanup section when a string error message occurs, ensuring proper resource release before exiting the function.

Conclusion

It is crucial for every aspiring and professional developer, coder, or programmer to understand the various types of errors in C programming, as well as the various methods for error handling.

• To begin with, syntax errors occur when commands are written incorrectly, causing them not to be understood by the computer.
• Logical errors are mistakes resulting in incorrect output due to faulty logic or incorrect input.
• Semantic errors happen when valid syntax does not produce expected results due to misunderstanding language rules and making assumptions about how code works.
• Linker errors arise from missing libraries/object codes needed for creating an executable, as well as forgetting certain compiler flags or using wrong flag values while compiling source code files.

Error handling is the umbrella term that comprises multiple methods in which one can take care of errors or resolve them.

• This can be done through errno values, which store system-defined values representing errors returned by library functions and system calls.
• One can also use perror(), strerror(), ferror() functions that prints out a description related to a given Errno value on stderr stream (standard error).
• The feof() is an alternate function that can be used directly after file operations, indicating if the end of the executable file has been reached successfully without any issues.
• This, along with the clearerr() function, helps reset individual flags associated with particular open streams properly before it can perform further read-write tasks thereupon within the program body.
• Lastly, exit status returns an integer type number relying upon whether zero (i.e., no problem identified) was encountered during execution

Frequently Asked Interview Questions

Q. What are the 3 major types of programming errors?

The 3 major types of error in programming are:

1. Syntax Error: These are errors that occur when the syntax of a programming language is not followed correctly, such as missing punctuation or incorrect spelling.
2. Run-time Error: Errors that occur while the program runs, often due to memory issues or improper data types used in calculations and comparisons.
3. Logical Error: Errors where the code is syntactically correct but logically wrong—for example, if an if-then statement returns an unexpected result because of faulty logic/ logical issues within its expression.

Q. What are the five 5 different types of error detection techniques?

The five types of error detection techniques in C are as follows:

1. Parity Check: This technique uses an extra bit (parity bit) to check the errors in data transmission. If the parity bits are mismatched, then an error has occurred during data transmission.
2. Checksum: It generates a checksum value for each block of source code and compares it with previously generated values for the current set of codes. This happens at the destination end after the decoding/ transmission or learning process over a network to detect any alteration or changes that happened due to malicious activities or own mistakes while information is transferred from one place to another through a network (like the Internet).
3. Cyclic Redundancy Check (CRC): This is the most widely used error detection scheme that divides the original message into fixed length blocks & runs the mathematical algorithm on these blocks known as ‘generating polynomial’. It also and creates a remainder, which gets appended with the last transmitting block as the CRC code word & transmitted along with other packet parts like address fields, control fields, etc. Likewise, the recipient side receives these packets & also verifies using the same generating polynomial before processing. If these are found to be different, then it means some alteration was caused by a third-party intruder or something wrong occurred midway. It discards that piece without getting choked up in the system.
4. Hamming Code: This is a single-bit error detection & correction scheme which utilizes extra bits with the data bits. This depends on powerful mathematical formulas & is intended to increase the reliability of the communication system by automatically detecting errors that occur in transmission & using suggestive mechanisms for correcting those errors.
5. Hashing Technique: Hash is a unique numerical value assigned based on a traditional message digest algorithm (like MD-5). It’s a one-way encryption technique, i.e., it isn't possible to decrypt it back. It is mainly used while sending confidential information between two parties or transferring sensitive bad file streams over networks like the internet due to its capability of verifying the integrity of transmitted messages from the sender end up-till destination.

Q. How many types of error handling are there in Java?

There are three primary methods of managing exceptions in Java, that is, try-catch, throw, and throws. You can check a part of the code for errors using the try block and create an exception handler that will be used when an error occurs using the catch block. And then, execute a section of code regardless of whether or not there is an error by using the final block. Additionally, although the throws keyword defines which exceptions may arise due to a method call, the throw keyword can also be used to cause an exception deliberately.

Q. What do you understand by an error in programming?

An error in programming refers to a mistake made by the programmer that prevents the program from completing successfully. Common key errors in C include syntax, logic, and runtime errors.

A syntax error occurs when program code does not conform to the rules of writing computer programs as specified by a language's grammar or defined standard. For example, if you forget to close off your brackets in some languages, this will cause an error.

Logic errors occur when an incorrect algorithm is used, which results in undefined behavior from what was expected. For example, if you accidentally set up your loop so it runs forever, it could freeze up your system!

Runtime errors happen during execution time due to insufficient input data or unexpected circumstances. For instance, entering a wrong command into the terminal can lead to the crashing of applications on Linux systems due to inadequate checks before executing commands.

While these are the three key types of errors in C, there are two other types of errors, i.e., semantic errors and linker errors.

You might also be interested in reading the following:

1. 100+ Top C Interview Questions With Answers (2023)
2. Constant In C | How To Define & Its Types Explained With Examples
3. Swapping Of Two Numbers In C | 5 Ways Explained (With Examples)
4. Difference Between C And C++| Features | Application & More!
5. Difference Between C And Embedded C Decoded!