A compilation error in C occurs when the C code you have written contains syntax errors or other problems that prevent the compiler from generating an executable program. When the compiler encounters an error in your code, it will stop the compilation process and provide an error message that describes the problem.

Some common causes of compilation errors in C include:

Syntax errors: Syntax errors occur when the code violates the syntax rules of the C language. These types of errors usually occur due to missing or misplaced symbols, such as semicolons, braces, or parentheses. A syntax error will prevent the code from compiling and will generate an error message.
Semantic errors: Semantic errors occur when the code compiles without any error message, but the program does not behave as expected. These errors occur due to logical or design flaws in the code, such as using the wrong variable or function, or using a variable before it is initialized.
Type errors: Type errors occur when there is a type mismatch between variables, expressions, or functions. This can occur when a variable or function is declared with one type and then used with a different type. Type errors can result in unexpected behavior or a program crash.
Linker errors: Linker errors occur when the linker is unable to find the required symbols or libraries needed to build the program. This can occur when a library or object file is missing or when the linker is unable to resolve symbol references.
Runtime errors: Runtime errors occur when the program is running and encounters an unexpected condition or error. These errors can occur due to logical errors or incorrect input data, such as divide-by-zero errors, array index out of bounds errors, or null pointer dereference errors.

To fix compilation errors in C, one needs to identify the cause of the error by reading the error message carefully and reviewing the code. Once the problem has been identified, one can correct the code and try to compile it again.

1. Syntax errors occur when the code violates the syntax rules of the C language. These errors are usually caused by missing or misplaced symbols, such as semicolons, braces, or parentheses.

Here is an example of a syntax error in C:

#include <stdio.h>
int main() {
printf("Hello, world!")
return 0;
}

In this code, there is a missing semicolon after the printf statement. This violates the syntax rules of C and will cause a syntax error when the code is compiled.

When this code is compiled, the compiler will generate an error message that looks something like this:

test.c: In function 'main':
test.c:4:3: error: expected ';' before 'return'
return 0;

This error message indicates that there is a syntax error on line 4 of the code. Specifically, the compiler was expecting a semicolon before the return statement, but it found something else instead.

To fix this error, we simply need to add the missing semicolon after the printf statement, like this:

#include <stdio.h>
int main() {
printf("Hello, world!");
return 0;
}

With the semicolon added, the code now compiles without errors and can be run to produce the expected output.

2. Semantic errors occur when the code compiles without any error message, but the program does not behave as expected. These errors occur due to logical or design flaws in the code, such as using the wrong variable or function, or using a variable before it is initialized.

Here's an example of a semantic error in C:

#include <stdio.h>
int main() {
int x;
int y = 5;
int z = x + y;
printf("z = %d\n", z);
return 0;
}

In this code, we declare three variables x, y, and z. We initialize y with the value 5, but we do not initialize x. Then we try to use x in the expression x + y to calculate the value of z.

The semantic error in this code is that we are using the value of an uninitialized variable, which can lead to undefined behavior.

When we compile and run this code, we get an unexpected result. Instead of the value of z being 5, as we might expect, it will have some random value because x has not been initialized. This is an example of a semantic error.

To fix this error, we need to initialize the variable x with a value before using it in the calculation.

For example, we could initialize it to 0:

#include <stdio.h>
int main() {
int x = 0;
int y = 5;
int z = x + y;
printf("z = %d\n", z);
return 0;
}

With this change, the program will behave as expected and the value of z will be 5.

3. Type errors occur when there is a type mismatch between variables, expressions, or functions. This can occur when a variable or function is declared with one type and then used with a different type. Type errors can result in unexpected behavior or a program crash.

Here's an example of a type error in C:

#include <stdio.h>
int main() {
int x = 5;
float y = 2.5;
int z = x + y;
printf("z = %d\n", z);
return 0;
}

In this code, we declare three variables x, y, and z. We initialize x with the value 5, and y with the value 2.5. Then we try to use x and y in the expression x + y to calculate the value of z.

The type error in this code is that we are trying to add a float value y to an integer value x, which is not allowed in C. This will result in a type mismatch error.

When we compile and run this code, we get an error message that looks something like this:

test.c: In function 'main':
test.c:5:12: error: invalid operands to binary + (have 'int' and 'float')
int z = x + y;

This error message indicates that there is a type error on line 5 of the code. Specifically, we are trying to add an integer and a float value, which is not allowed.

To fix this error, we need to convert the float value y to an integer before adding it to x.

We can do this by using a typecast operator:

#include <stdio.h>
int main() {
int x = 5;
float y = 2.5;
int z = x + (int)y;
printf("z = %d\n", z);
return 0;
}

With this change, the program will behave as expected and the value of z will be 7.

4. Linker errors occur during the linking phase of the compilation process. They occur when the linker is unable to link together all of the object files and libraries that are needed to create the final executable. Linker errors can occur for a variety of reasons, such as missing symbols or incompatible library versions.

Here's an example of a linker error in C:

#include <stdio.h>
int main() {
printf("Hello, world!\n");
myFunction();
return 0;
}

In this code, we have a call to a function called myFunction() that has not been defined in this file.

When we compile this code, the compiler will create an object file containing the compiled code for the main() function. However, since the myFunction() function has not been defined in this file, the linker will be unable to link the object file with the missing symbol, resulting in a linker error.

The error message might look something like this:

Undefined symbols for architecture x86_64:
  "_myFunction", referenced from:
      _main in main.o
ld: symbol(s) not found for architecture x86_64

This error message indicates that the linker is unable to find the symbol for myFunction() in any of the object files or libraries that have been linked.

To fix this error, we need to provide a definition for the myFunction() function, either by defining it in the same file or by linking to a library that contains the definition.

For example:

#include <stdio.h>
void myFunction() {
printf("This is my function.\n");
}


int main() {
printf("Hello, world!\n");
myFunction();
return 0;
}

With this change, the program will compile and link successfully, and the output will be:

Output:

Hello, world!
This is my function.

5. Runtime errors occur during the execution of a program. They can occur for a variety of reasons, such as invalid input, divide-by-zero errors, accessing memory that has not been allocated, or calling a function with the wrong number or type of arguments.

Here's an example of a runtime error in C:

#include <stdio.h>
int main() {
int x = 5;
int y = 0;
int z = x / y;
printf("z = %d\n", z);
return 0;
}

In this code, we declare two integer variables x and y, and initialize x with the value 5 and y with the value 0. Then we try to divide x by y to calculate the value of z.

The runtime error in this code is that we are trying to divide an integer by 0, which is not allowed in C. This will result in a divide-by-zero error at runtime.

When we compile and run this code, we get an error message that looks something like this:

Floating point exception (core dumped)

This error message indicates that a floating point exception occurred at runtime, which typically means that we attempted an invalid arithmetic operation, such as dividing by zero.

To fix this error, we need to check if the value of y is zero before performing the division.

We can do this with an if statement:

#include <stdio.h>
int main() {
int x = 5;
int y = 0;
if (y != 0) {
int z = x / y;
printf("z = %d\n", z);
  } else {
printf("Error: Division by zero.\n");
  }
return 0;
}

Output:

Error: Division by zero.

With this change, the program will check if y is zero before attempting the division, and will print an error message instead of crashing if y is zero.

C Tutorial

C Tutorial

Compilation Errors in C