List of 100 Common C Errors Explanations & Solutions

Programming in C can be an exciting and rewarding experience, but it’s not without its challenges. Even the most seasoned developers encounter errors during their coding journey. Understanding these errors and knowing how to troubleshoot them is crucial for writing robust and error-free C programs.

In this article, we delve into the realm of common C errors, exploring their error codes and providing clear explanations and solutions. Whether you’re a beginner starting your programming journey or an experienced developer seeking to sharpen your skills, this guide will serve as a valuable resource to help you overcome common stumbling blocks in C programming.

We’ve compiled a comprehensive list of 100 common C errors, ranging from syntactical mistakes to logical errors and memory management issues. For each error, we provide a detailed explanation of what causes it and offer practical solutions to rectify the problem. Our aim is to make this resource as human-friendly as possible, enabling you to grasp the concepts easily and apply the solutions effectively.

Throughout this guide, we’ll touch on various aspects of C programming, including variable declaration and initialization, array handling, pointer usage, function calls, file operations, and more. By gaining a deeper understanding of these errors and how to address them, you’ll not only improve your programming skills but also enhance the reliability and efficiency of your C programs.

It’s important to note that our explanations and solutions are presented in a way that emphasizes clarity and readability. We understand that programming can be complex, but our goal is to simplify these concepts, making them accessible to programmers of all levels.

So whether you’re wrestling with issues like using uninitialized variables, mishandling file operations, or struggling with incorrect format specifiers in printf() and scanf() functions, this guide will equip you with the knowledge and techniques needed to overcome these challenges. By becoming familiar with these common errors and their resolutions, you’ll be well on your way to writing cleaner, more robust C code.

So let’s dive in and explore the intriguing world of common C errors. Together, we’ll unravel their mysteries and arm ourselves with the skills needed to conquer them.

Table of Contents

Common C Errors Explanations & Solutions

Error	Explanation	Solution
1.	Forgetting to include a necessary header file.	This error occurs when you don’t include the required header file that contains the necessary declarations for functions or types you’re using. To fix this, ensure that you include the appropriate header file at the beginning of your code.
2.	Missing a semicolon at the end of a statement.	Forgetting to put a semicolon at the end of a statement is a common mistake. C treats each statement as a separate entity, and the semicolon is used to mark the end of a statement. To resolve this error, simply add a semicolon at the end of the line where the error occurs.
3.	Using an uninitialized variable.	Using a variable that hasn’t been assigned a value can lead to unexpected behavior or crashes. To fix this, initialize the variable with a value before using it.
4.	Declaring a variable with an incorrect type.	Declaring a variable with the wrong data type can cause issues with assignments or operations. Make sure you choose the appropriate data type that matches the intended usage of the variable. Check the variable declaration and ensure it matches the type you intend to use.
5.	Using an undeclared variable.	This error occurs when you use a variable that hasn’t been declared or defined in the current scope. To resolve this, make sure you declare the variable before using it. If the variable is defined in a different scope, consider the scope rules and make the necessary adjustments.
6.	Incorrectly using the assignment operator (=) instead of the equality operator (==).	The assignment operator (=) is used to assign a value to a variable, while the equality operator (==) is used to compare values for equality. If you mistakenly use the assignment operator in a comparison, it will result in unexpected behavior. Review the code and replace any instances where you intended to compare values with the equality operator (==).
7.	Comparing strings using the equality operator (==) instead of the strcmp() function.	In C, you can’t directly compare strings using the equality operator (==) because it compares the memory addresses instead of the actual string contents. To compare strings, use the strcmp() function from the string.h header file. It returns 0 if the strings are equal.
8.	Not closing a file after opening it.	When working with files, it’s important to close them after you’re done to release system resources. Neglecting to close a file can lead to resource leaks or issues with subsequent file operations. After performing file operations, remember to call the fclose() function to close the file.
9.	Accessing an array out of bounds.	Trying to access an array element beyond its defined size can lead to undefined behavior or segmentation faults. Ensure that you stay within the bounds of the array by accessing valid indices from 0 to size-1. Double-check your array accesses and make sure they are within the valid range.
10.	Forgetting to free dynamically allocated memory using the free() function.	When you dynamically allocate memory using functions like malloc(), calloc(), or realloc(), it’s essential to free that memory when you no longer need it. Forgetting to free allocated memory can result in memory leaks. Remember to use the free() function to release dynamically allocated memory.
11.	Confusing the order of arguments in a function call.	The order of arguments in a function call must match the order of parameters in the function declaration or definition. If the order is incorrect, it can lead to unexpected behavior. Check the function signature and ensure that the arguments are provided in the correct order.
12.	Using the wrong format specifier in a printf() or scanf() function.	The format specifier in printf() and scanf() functions specifies the type of data being printed or read. Using the wrong format specifier can lead to incorrect output or unexpected behavior. Double-check the format specifiers in your printf() and scanf() statements and make sure they match the data types you are working with.
13.	Using the wrong type of format specifier in a printf() or scanf() function.	Similar to using the wrong format specifier, using the wrong type of format specifier can result in incorrect output or unexpected behavior. Ensure that the format specifier matches the data type of the variable being printed or read. Review the format specifiers and verify their compatibility with the corresponding variables.
14.	Using a pointer before allocating memory for it.	Pointers must be assigned valid memory addresses before they can be used. Using a pointer that hasn’t been properly allocated can lead to segmentation faults or undefined behavior. Allocate memory for the pointer using functions like malloc() or calloc() before using it.
15.	Incorrectly dereferencing a pointer.	Dereferencing a pointer involves accessing the value it points to using the * operator. Incorrectly dereferencing a pointer, such as dereferencing a null pointer, can result in crashes or undefined behavior. Ensure that the pointer is valid and not null before dereferencing it.
16.	Misusing the sizeof() operator.	The sizeof() operator is used to determine the size of a data type or an object in bytes. Misusing this operator, such as applying it to a pointer or using it with dynamically allocated memory, can lead to incorrect results. Understand the proper usage of the sizeof() operator and apply it appropriately.
17.	Using a function before declaring or defining it.	If you use a function before declaring or defining it, the compiler may not recognize the function, resulting in an error. To fix this, make sure to declare or define the function before using it. Consider placing function declarations in header files for better organization and to avoid this error.
18.	Not initializing a structure variable properly.	When working with structures, it’s crucial to initialize all members to appropriate values before using them. Leaving structure members uninitialized can lead to undefined behavior or unexpected results. Initialize structure variables with valid values or use memset() to set them to zero.
19.	Attempting to modify a string literal.	String literals in C are read-only, and attempting to modify them directly can result in undefined behavior. If you need to modify a string, use an array of characters or dynamically allocate memory for the string. Make sure to use appropriate functions like strcpy() or strcat() to manipulate strings safely.
20.	Incorrectly using the conditional (ternary) operator.	The conditional operator (?:) allows you to write concise conditional expressions. However, using it incorrectly, such as assigning values to variables within the conditional expression, can lead to unexpected behavior. Ensure that the conditional operator is used appropriately for evaluating and assigning values in conditional expressions.
21.	Using an incorrect format specifier for a specific data type.	Each data type in C requires a specific format specifier in functions like printf() and scanf(). Using an incorrect format specifier can result in incorrect output or reading wrong values. Refer to the C documentation or appropriate resources to identify the correct format specifier for the data type you are working with.
22.	Confusing bitwise operators (&,	, ^) with logical operators (&&,
23.	Ignoring the return value of a function.	Functions often return values that may contain important information or error codes. Ignoring the return value can lead to incorrect program flow or missed error handling. Make sure to capture and handle the return value of functions appropriately based on their purpose.
24.	Using a variable after it has gone out of scope.	Variables in C have a specific scope within which they are valid and accessible. Using a variable outside its scope can result in undefined behavior or compilation errors. Ensure that variables are used within their appropriate scopes and consider their lifetime when accessing them.
25.	Incorrectly nesting if-else statements.	Nesting if-else statements allows for complex conditional logic. However, incorrect nesting can lead to unexpected results or logic errors. Review your if-else statements and ensure that they are nested correctly to reflect your intended logic. Consider using indentation or braces to improve code readability and prevent nesting errors.
26.	Dividing an integer by zero.	Dividing an integer by zero in C is undefined behavior and can result in crashes or incorrect results. Ensure that you avoid dividing by zero in your calculations. If necessary, use conditional statements to check for zero denominators before performing division operations.
27.	Comparing floating-point numbers using the equality operator (==).	Due to the way floating-point numbers are represented in memory, comparing them directly with the equality operator can lead to inaccurate results. Instead, consider using an epsilon value or a comparison function to check for approximate equality between floating-point numbers.
28.	Using the comma operator incorrectly.	The comma operator allows combining expressions, but it evaluates all expressions and returns the result of the last expression. Misusing the comma operator or using it inappropriately within expressions can lead to unexpected behavior. Understand the purpose and behavior of the comma operator and use it judiciously.
29.	Misusing the sizeof() operator with dynamic memory allocation.	The sizeof() operator returns the size of a data type or an object at compile-time. Misusing it with dynamic memory allocation, such as passing a pointer argument to sizeof(), can lead to unexpected results. Remember that sizeof() does not work with dynamically allocated memory and adjust your code accordingly.
30.	Using the wrong number of arguments in a function call.	Functions in C require a specific number of arguments based on their declaration or definition. Using the wrong number of arguments can result in compilation errors or incorrect behavior. Check the function signature and ensure that the number of arguments matches the function’s requirements.
31.	Not using the break statement in a switch statement.	In a switch statement, forgetting to include the break statement after a case will cause the code to “fall through” to subsequent cases, leading to unintended behavior. Always include the break statement at the end of each case to exit the switch block after the corresponding case is executed.
32.	Using an incorrect escape sequence in a string.	Escape sequences in C allow you to represent special characters. Using incorrect or unsupported escape sequences in strings can result in compilation errors or unexpected output. Verify that the escape sequences you use are valid and correspond to the desired special characters.
33.	Declaring a function inside another function.	In C, functions cannot be defined inside other functions. Attempting to do so will result in a compilation error. Move the function declaration outside the enclosing function or consider using function prototypes to forward-declare functions as needed.
34.	Assigning a value to a constant variable.	Constant variables in C are read-only and cannot be modified once assigned. Attempting to assign a value to a constant variable will cause a compilation error. If you need a variable that can be modified, use a regular variable instead.
35.	Using a reserved keyword as a variable or function name.	C reserves certain keywords for its syntax and functionality, and you cannot use them as variable or function names. Attempting to use a reserved keyword will result in a compilation error. Choose a different name that is not a reserved keyword for your variables and functions.
36.	Mixing signed and unsigned integers in an expression.	Mixing signed and unsigned integers in the same expression can lead to unexpected results due to the differences in their representations and behavior. Ensure consistency between signed and unsigned integers in expressions to avoid potential issues.
37.	Using a non-constant expression as the size of a static array.	In C, the size of a static array must be a constant expression known at compile-time. Using a non-constant expression as the size of a static array will result in a compilation error. If you need to dynamically allocate memory, consider using dynamic arrays (allocated using malloc() or calloc()) or other suitable data structures.
38.	Using the wrong format specifier in a printf() or scanf() function can lead to incorrect output or unexpected behavior. Double-check the format specifiers in your printf() and scanf() statements and make sure they match the data types you are working with.
45.	Using an incorrect condition in a loop.	The condition in a loop determines when the loop should continue or terminate. Using an incorrect condition can result in an infinite loop or prematurely exiting the loop. Double-check the loop condition and ensure it evaluates to the desired logic for loop execution.
46.	Accessing a NULL pointer.	A NULL pointer does not point to any valid memory address and attempting to access it can lead to crashes or undefined behavior. Always check if a pointer is NULL before dereferencing it to ensure it is valid and points to valid memory.
47.	Declaring a variable with the same name as a function.	Declaring a variable with the same name as a function will result in a compilation error as it causes conflicts between the variable and the function name. Choose a different name for the variable to resolve the error.
48.	Using a reserved keyword as a variable or function name.	C reserves certain keywords for its syntax and functionality, and you cannot use them as variable or function names. Attempting to use a reserved keyword will result in a compilation error. Choose a different name that is not a reserved keyword for your variables and functions.
49.	Mixing signed and unsigned integers in an expression.	Mixing signed and unsigned integers in the same expression can lead to unexpected results due to the differences in their representations and behavior. Ensure consistency between signed and unsigned integers in expressions to avoid potential issues.
50.	Using a non-constant expression as the size of a static array.	In C, the size of a static array must be a constant expression known at compile-time. Using a non-constant expression as the size of a static array will result in a compilation error. If you need to dynamically allocate memory, consider using dynamic arrays (allocated using malloc() or calloc()) or other suitable data structures.
51.	Trying to modify a string literal.	String literals in C are read-only and attempting to modify them directly can lead to undefined behavior. If you need to modify a string, use an array of characters or dynamically allocate memory for the string. Make sure to use appropriate functions like strcpy() or strcat() to manipulate strings safely.
52.	Incorrectly using the conditional (ternary) operator.	The conditional operator (?:) allows you to write concise conditional expressions. However, using it incorrectly, such as assigning values to variables within the conditional expression, can lead to unexpected behavior. Ensure that the conditional operator is used appropriately for evaluating and assigning values in conditional expressions.
53.	Using an incorrect format specifier for a specific data type.	Each data type in C requires a specific format specifier in functions like printf() and scanf(). Using an incorrect format specifier can result in incorrect output or reading wrong values. Refer to the C documentation or appropriate resources to identify the correct format specifier for the data type you are working with.
54.	Confusing bitwise operators (&,	, ^) with logical operators (&&,
55.	Ignoring the return value of a function.	Functions often return values that may contain important information or error codes. Ignoring the return value can lead to incorrect program flow or missed error handling. Make sure to capture and handle the return value of functions appropriately based on their purpose.
56.	Using a variable after it has gone out of scope.	Variables in C have a specific scope within which they are valid and accessible. Using a variable outside its scope can result in undefined behavior or compilation errors. Ensure that variables are used within their appropriate scopes and consider their lifetime when accessing them.
57.	Incorrectly nesting if-else statements.	Nesting if-else statements allows for complex conditional logic. However, incorrect nesting can lead to unexpected results or logic errors. Review your if-else statements and ensure that they are nested correctly to reflect your intended logic. Consider using indentation or braces to improve code readability and prevent nesting errors.
58.	Dividing an integer by zero.	Dividing an integer by zero in C is undefined behavior and can result in crashes or incorrect results. Ensure that you avoid dividing by zero in your calculations. If necessary, use conditional statements to check for zero denominators before performing division operations.
59.	Comparing floating-point numbers using the equality operator (==).	Due to the way floating-point numbers are represented in memory, comparing them directly with the equality operator can lead to inaccurate results. Instead, consider using an epsilon value or a comparison function to check for approximate equality between floating-point numbers.
60.	Using the comma operator incorrectly.	The comma operator allows combining expressions, but it evaluates all expressions and returns the result of the last expression. Misusing the comma operator or using it inappropriately within expressions can lead to unexpected behavior. Understand the purpose and behavior of the comma operator and use it judiciously.
61.	Misusing the sizeof() operator with dynamic memory allocation.	The sizeof() operator returns the size of a data type or an object at compile-time. Misusing it with dynamic memory allocation, such as passing a pointer argument to sizeof(), can lead to unexpected results. Remember that sizeof() does not work with dynamically allocated memory and adjust your code accordingly.
62.	Using the wrong number of arguments in a function call.	Functions in C require a specific number of arguments based on their declaration or definition. Using the wrong number of arguments can result in compilation errors or incorrect behavior. Check the function signature and ensure that the number of arguments matches the function’s requirements.
63.	Not using the break statement in a switch statement.	In a switch statement, forgetting to include the break statement after a case will cause the code to “fall through” to subsequent cases, leading to unintended behavior. Always include the break statement at the end of each case to exit the switch block after the corresponding case is executed.
64.	Using an incorrect escape sequence in a string.	Escape sequences in C allow you to represent special characters. Using incorrect or unsupported escape sequences in strings can result in compilation errors or unexpected output. Verify that the escape sequences you use are valid and correspond to the desired special characters.
65.	Declaring a function inside another function.	In C, functions cannot be defined inside other functions. Attempting to do so will result in a compilation error. Move the function declaration outside the enclosing function or consider using function prototypes to forward-declare functions as needed.
66.	Assigning a value to a constant variable.	Constant variables in C are read-only and cannot be modified once assigned. Attempting to assign a value to a constant variable will cause a compilation error. If you need a variable that can be modified, use a regular variable instead.
67.	Using a reserved keyword as a variable or function name.	C reserves certain keywords for its syntax and functionality, and you cannot use them as variable or function names. Attempting to use a reserved keyword will result in a compilation error. Choose a different name that is not a reserved keyword for your variables and functions.
68.	Mixing signed and unsigned integers in an expression.	Mixing signed and unsigned integers in the same expression can lead to unexpected results due to the differences in their representations and behavior. Ensure consistency between signed and unsigned integers in expressions to avoid potential issues.
69.	Using a non-constant expression as the size of a static array.	In C, the size of a static array must be a constant expression known at compile-time. Using a non-constant expression as the size of a static array will result in a compilation error. If you need to dynamically allocate memory, consider using dynamic arrays (allocated using malloc() or calloc()) or other suitable data structures.
70.	Forgetting to include a necessary header file.	This error occurs when you forget to include the required header file that contains the necessary declarations for functions or types you’re using. To fix this, ensure that you include the appropriate header file at the beginning of your code.
71.	Missing a semicolon at the end of a statement.	Forgetting to put a semicolon at the end of a statement is a common mistake. C treats each statement as a separate entity, and the semicolon is used to mark the end of a statement. To resolve this error, simply add a semicolon at the end of the line where the error occurs.
72.	Using an uninitialized variable.	Using a variable that hasn’t been assigned a value can lead to unexpected behavior or crashes. To fix this, initialize the variable with a value before using it.
73.	Declaring a variable with an incorrect type.	Declaring a variable with the wrong data type can cause issues with assignments or operations. Make sure you choose the appropriate data type that matches the intended usage of the variable. Check the variable declaration and ensure it matches the type you intend to use.
74.	Using an undeclared variable.	This error occurs when you use a variable that hasn’t been declared or defined in the current scope. To resolve this, make sure you declare the variable before using it. If the variable is defined in a different scope, consider the scope rules and make the necessary adjustments.
75.	Incorrectly using the assignment operator (=) instead of the equality operator (==).	The assignment operator (=) is used to assign a value to a variable, while the equality operator (==) is used to compare values for equality. If you mistakenly use the assignment operator in a comparison, it will result in unexpected behavior. Review the code and replace any instances where you intended to compare values with the equality operator (==).
76.	Comparing strings using the equality operator (==) instead of the strcmp() function.	In C, you can’t directly compare strings using the equality operator (==) because it compares the memory addresses instead of the actual string contents. To compare strings, use the strcmp() function from the string.h header file. It returns 0 if the strings are equal.
77.	Not closing a file after opening it.	When working with files, it’s important to close them after you’re done to release system resources. Neglecting to close a file can lead to resource leaks or issues with subsequent file operations. After performing file operations, remember to call the fclose() function to close the file.
78.	Accessing an array out of bounds.	Trying to access an array element beyond its defined size can lead to undefined behavior or segmentation faults. Ensure that you stay within the bounds of the array by accessing valid indices from 0 to size-1. Double-check your array accesses and make sure they are within the valid range.
79.	Forgetting to free dynamically allocated memory using the free() function.	When you dynamically allocate memory using functions like malloc(), calloc(), or realloc(), it’s essential to free that memory when you no longer need it. Forgetting to free allocated memory can result in memory leaks. Remember to use the free() function to release dynamically allocated memory.
80.	Confusing the order of arguments in a function call.	The order of arguments in a function call must match the order of parameters in the function declaration or definition. If the order is incorrect, it can lead to unexpected behavior. Check the function signature and ensure that the arguments are provided in the correct order.
81.	Using the wrong format specifier in a printf() or scanf() function.	The format specifier in printf() and scanf() functions specifies the type of data being printed or read. Using the wrong format specifier can lead to incorrect output or unexpected behavior. Double-check the format specifiers in your printf() and scanf() statements and make sure they match the data types you are working with.
82.	Using the wrong type of format specifier in a printf() or scanf() function.	Similar to using the wrong format specifier, using the wrong type of format specifier can result in incorrect output or unexpected behavior. Ensure that the format specifier matches the data type of the variable being printed or read. Review the format specifiers and verify their compatibility with the corresponding variables.
83.	Using a pointer before allocating memory for it.	Pointers must be assigned valid memory addresses before they can be used. Using a pointer that hasn’t been properly allocated can lead to segmentation faults or undefined behavior. Allocate memory for the pointer using functions like malloc() or calloc() before using it.
84.	Incorrectly dereferencing a pointer.	Dereferencing a pointer involves accessing the value it points to using the * operator. Incorrectly dereferencing a pointer, such as dereferencing a null pointer, can result in crashes or undefined behavior. Ensure that the pointer is valid and not null before dereferencing it.
85.	Misusing the sizeof() operator.	The sizeof() operator is used to determine the size of a data type or an object in bytes. Misusing this operator, such as applying it to a pointer or using it with dynamically allocated memory, can lead to incorrect results. Understand the proper usage of the sizeof() operator and apply it appropriately.
86.	Using a function before declaring or defining it.	If you use a function before declaring or defining it, the compiler may not recognize the function, resulting in an error. To fix this, make sure to declare or define the function before using it. Consider placing function declarations in header files for better organization and to avoid this error.
87.	Not initializing a structure variable properly.	When working with structures, it’s crucial to initialize all members to appropriate values before using them. Leaving structure members uninitialized can lead to undefined behavior or unexpected results. Initialize structure variables with valid values or use memset() to set them to zero.
88.	Attempting to modify a string literal.	String literals in C are read-only, and attempting to modify them directly can lead to undefined behavior. If you need to modify a string, use an array of characters or dynamically allocate memory for the string. Make sure to use appropriate functions like strcpy() or strcat() to manipulate strings safely.
89.	Incorrectly using the conditional (ternary) operator.	The conditional operator (?:) allows you to write concise conditional expressions. However, using it incorrectly, such as assigning values to variables within the conditional expression, can lead to unexpected behavior. Ensure that the conditional operator is used appropriately for evaluating and assigning values in conditional expressions.
90.	Using an incorrect format specifier for a specific data type.	Each data type in C requires a specific format specifier in functions like printf() and scanf(). Using an incorrect format specifier can result in incorrect output or reading wrong values. Refer to the C documentation or appropriate resources to identify the correct format specifier for the data type you are working with.
91.	Confusing bitwise operators (&,	, ^) with logical operators (&&,
92.	Ignoring the return value of a function.	Functions often return values that may contain important information or error codes. Ignoring the return value can lead to incorrect program flow or missed error handling. Make sure to capture and handle the return value of functions appropriately based on their purpose.
93.	Using a variable after it has gone out of scope.	Variables in C have a specific scope within which they are valid and accessible. Using a variable outside its scope can result in undefined behavior or compilation errors. Ensure that variables are used within their appropriate scopes and consider their lifetime when accessing them.
94.	Incorrectly nesting if-else statements.	Nesting if-else statements allows for complex conditional logic. However, incorrect nesting can lead to unexpected results or logic errors. Review your if-else statements and ensure that they are nested correctly to reflect your intended logic. Consider using indentation or braces to improve code readability and prevent nesting errors.
95.	Dividing an integer by zero.	Dividing an integer by zero in C is undefined behavior and can result in crashes or incorrect results. Ensure that you avoid dividing by zero in your calculations. If necessary, use conditional statements to check for zero denominators before performing division operations.
96.	Comparing floating-point numbers using the equality operator (==).	Due to the way floating-point numbers are represented in memory, comparing them directly with the equality operator can lead to inaccurate results. Instead, consider using an epsilon value or a comparison function to check for approximate equality between floating-point numbers.
97.	Using the comma operator incorrectly.	The comma operator allows combining expressions, but it evaluates all expressions and returns the result of the last expression. Misusing the comma operator or using it inappropriately within expressions can lead to unexpected behavior. Understand the purpose and behavior of the comma operator and use it judiciously.
98.	Misusing the sizeof() operator with dynamic memory allocation.	The sizeof() operator returns the size of a data type or an object at compile-time. Misusing it with dynamic memory allocation, such as passing a pointer argument to sizeof(), can lead to unexpected results. Remember that sizeof() does not work with dynamically allocated memory and adjust your code accordingly.
99.	Using the wrong number of arguments in a function call.	Functions in C require a specific number of arguments based on their declaration or definition. Using the wrong number of arguments can result in compilation errors or incorrect behavior. Check the function signature and ensure that the number of arguments matches the function’s requirements.
100.	Not using the break statement in a switch statement.	In a switch statement, forgetting to include the break statement after a case will cause the code to “fall through” to subsequent cases, leading to unintended behavior. Always include the break statement at the end of each case to exit the switch block after the corresponding case is executed.