C Compile Time Vs Runtime Differences And Examples

Both compile-time and runtime pertain to distinct categories of errors. Initially, let's delve into the definitions of compile time and runtime. Subsequently, we will examine the disparities between them.

What are Compile-Time Errors?

In C programming, compile-time errors arise from incorrect syntax or semantics in the code. These errors are detected by the compiler during the compilation process. The program cannot be executed until all compile-time errors are resolved. Upon successful error correction, the compiler produces the executable file.

Types of Compiler-Time Error

There are two categories of compile-time errors in C programming. These errors include:

Here, we will examine each of these compile-time errors individually.

1) Syntax errors

In the realm of C programming, a syntax error is a form of error that the compiler detects when the correct syntax of the programming language is not adhered to.

For example:

int a, b:

Explanation:

The declaration above results in a compile-time error due to the requirement in C programming that each statement should conclude with a semicolon. In this case, using a colon (:) instead of a semicolon at the statement's end leads to a syntax error.

2) Semantic Errors

In the realm of C programming, a semantic error is a form of mistake that arises when the syntax is accurate, yet the logic or statement is flawed. These errors elude detection by the compiler, resulting in the generation of inaccurate outcomes.

For example:

a+b=c;

Explanation:

Assigning the value of 'c' to the sum of 'a' and 'b' results in a compile-time error in C programming. The language only allows one variable on the left side of the assignment operator, whereas the right side can have multiple variables.

Therefore, we can rewrite the above statement as:

c=a+b;

What is a Runtime Error?

In C programming, runtime errors refer to errors that occur during program execution, bypassing the compiler's detection. These errors, such as division by zero, are challenging to identify since they are not caught during compilation.

Types of Runtime Error

Let's examine common types of C runtime errors, scenarios, and the potential impacts they can have.

Here, we will address each of these runtime errors individually.

1) Division by Zero

Due to the fact that dividing by zero is undefined in mathematics, trying to divide an integer by zero results in a runtime error. This error leads to the program either crashing or generating an exception.

C Runtime Error using Division by Zero

Let's consider a scenario to demonstrate a runtime error involving division by zero in the C programming language.

Example

#include <stdio.h>  

int main() {  

    int x = 5;  

    int y = 0;  

    int result = x / y; 

    printf("After performing the division, the result is :  %d\n", result);  

    // Runtime error

    return 0;  

}

Output:

Floating point exception

Explanation:

In this instance, we've selected two integer values, x and y, and assigned specific values to them. Following this, we declared a new integer variable (result) to store the result of the division operation between x and y. Subsequently, we displayed the resulting outcome. The output reveals a "Floating point exception" error message, indicating a runtime problem arising from attempting to divide by zero.

2) Accessing Array Out of Bounds

A runtime error occurs when attempting to access an element in an array beyond its defined boundaries. This error arises when an index exceeds the size of the array, violating memory access rules.

Encountering a C Runtime error due to Accessing Array Out of Bounds:

Let's consider a scenario to demonstrate a runtime error caused by accessing an array out of its bounds in the C programming language.

Example

#include <stdio.h>  

   

int main() {  

    int arr[5] = {1, 2, 3, 4, 5};  

    int index = 10;  

    int value = arr[index]; // Accessing array out of bounds  

    printf("Value: %d\n", value);  

    return 0;  

}

Output:

Value: 1529283018

Segmentation fault (core dumped)

Explanation:

In this instance, we are using an array called arr with indices ranging from 0 to 4. However, the script attempts to access arr[10], exceeding the array's limits. This leads to undefined behavior, where the program could display random data, crash, or exhibit erratic behavior due to C's lack of automatic boundary verification.

3) Null Pointer Dereference

A runtime error arises when attempting to access the memory address of a null pointer, a situation referred to as dereferencing a null pointer. Accessing null pointers leads to unpredictable outcomes as they do not point to valid memory locations.

In the following example, a C runtime error is demonstrated through a null pointer dereference scenario.

1. A null pointer is assigned to a pointer variable:
Example
Copy
int* ptr = NULL;
Try it Yourself
2. Attempting to dereference the null pointer leads to a runtime error:
Example
Copy
int value = *ptr;  // Causes a runtime error
Try it Yourself
3. The runtime error occurs because the program tries to access memory at address 0, which is not allowed.

Let's consider an illustration to demonstrate a runtime error caused by dereferencing a null pointer in the C programming language.

Example

#include <stdio.h>  

   

int main() {  

    int* ptr = NULL; // Null pointer  

    int value = *ptr; // Null pointer dereference  

    printf("Value: %d\n", value);  

    return 0;  

}

Output:

Segmentation fault (core dumped)

Explanation:

In this instance, we declared an integer pointer variable * ptr and assigned it a NULL value. Subsequently, we defined another integer variable and attempted to dereference the NULL pointer. Following this, we displayed the resulting output. Notably, trying to dereference a null pointer led to a segmentation fault, causing the program to terminate unexpectedly with an error notification.

4) Stack Overflow

In C programming, a stack overflow occurs when the call stack exceeds its intended size, storing information related to function calls. Infinite recursion typically occurs when recursive functions lack proper termination conditions.

C Runtime Error Example using Stack Overflow

Let's consider an example to demonstrate a runtime error by causing a stack overflow in the C programming language.

Example

#include <stdio.h>  

void recursiveFunction() {  

    recursiveFunction(); // Recursive call without termination condition  

}  

int main() {  

    recursiveFunction();  

    return 0;  

}

Output:

Segmentation fault (core dumped)

Explanation:

In this instance, we define a recursiveMethod function wherein we execute a recursive invocation lacking a base case, followed by method termination. Subsequently, the primary function is established, calling the recursiveMethod. The resultant output reveals an infinite recursion scenario, leading to stack overflow and eventual segmentation fault.

5) Uninitialized Variables

When uninitialized variables are encountered, they hold undefined values. This implies that when a variable is declared without being initialized first, it will contain an undefined value. This scenario can lead to unexpected outcomes or program crashes, depending on the context.

In this example, we will demonstrate a C runtime error caused by using uninitialized variables. This type of error occurs when a variable is accessed before it has been assigned a specific value.

Consider the following code snippet:

#include <stdio.h>

int main() {
    int x;
    int y;

    int z = x + y;
    
    printf("The sum of x and y is: %d\n", z);
    
    return 0;
}

In this code, variables x and y are declared but not initialized with any values. The variable z is then assigned the sum of x and y, which results in using uninitialized values. When the program is executed, it will lead to a runtime error due to the use of uninitialized variables.

It is essential to always initialize variables before using them to avoid such runtime errors in C programming.

Let's consider a scenario to demonstrate a runtime error caused by using uninitialized variables in the C programming language.

Example

#include <stdio.h>  

   

int main() {    //main function

    int uninitializedVariable;  

    printf("Value: %d\n", uninitializedVariable); // Using uninitialized variable  

    return 0;  

}

Output:

Value: 32765

Value: 32767

Value: 32764

Some random value (varies each time)

Explanation:

In this instance, an integer variable has been initialized within the main function. Subsequently, an attempt was made to display the value of this initialized variable. The resultant output reflects a random value. This occurs due to the nature of uninitialized variables which can hold any arbitrary value sourced from the memory region allocated to them.

Main differences between Compile-time and Runtime Errors in C

There exist several key distinctions between compile-time and runtime errors in C programming. Some primary variances include:

Compile-time and Runtime Examples:

Let's consider various instances to demonstrate the contrast between compile-time and runtime errors in the C programming language.

Example of a Compile-time error

Let's consider a scenario to demonstrate a compile-time error in the C programming language.

Example

#include <stdio.h>  

int main( )  

{  

    char s = '3':  

    printf("The value assigned to the integer variable s is : %c", s);

    return 0;  

}

Output:

ERROR!

/tmp/05CinY1EAB/main.c:4:17: error: expected ',' or ';' before ':' token

    4 |     char s = '3':

      |

Explanation:

In this instance, a character value has been assigned to the character variable 's'. Subsequently, when attempting to print the value of 's', an error is encountered. The error arises from the presence of a colon (:) at the statement's conclusion instead of a semicolon, resulting in a compile-time error.

C Example of Runtime Error

Let's consider a scenario to demonstrate a runtime error in C programming.

Example

#include <stdio.h>  

int main()  

{  

    int x = 12;  

    int y = 0; 

    // division by zero  

    printf("The result after performing the division is : %d", x/y);

    return 0;  

}

Output:

Floating point exception

Explanation:

In this instance, attempting to divide an integer x(12)/y(0) results in a runtime error due to the undefined nature of division by zero in the C language. Despite successful compilation of the program, it will ultimately crash or exhibit erratic behavior during execution.

Conclusion

In summary, compile-time errors occur during compilation and halt program execution, typically arising from syntax, semantics, or type errors. Conversely, runtime errors manifest during program execution despite successful compilation, evading detection by the compiler. It is crucial to detect and address both types of errors to guarantee proper and dependable program operation.