In a switch construct, why doesn't the compiler show any error and skips the statements written within the cases like for example I write printf("hello"); in between case 1 and case 2, so why is there no error in this and how come the compiler skips this step?
For example I write
case 1: int a=9; break;
printf("hellooo");
case 2 : int y =98;
printf("kill");
break;
So here when parsing is done either the compiler should throw any error because of the printf statement or it must print the statement which is written between the two cases but it skips it. Why does it happen?
Okay, lets start with the fact that most C compilers are minimalist - meaning that they check syntax and minimal semantics. In a switch statement, the definition of the statement is
swittch(expression) {
case
case
default
}
At runtime, evaluation of the expression determines which (if any) case maps to the value of the expression. there is no requirement that a break statement exist between each (or any) of the cases. There is *no* way for the minimalist compiler to catch the problem you've defined. A more exhaustive compiler checking should return a warning that the printf("helloo"); is unreachable.
It IS not a compilation error for this statement to be there - there is nothing syntactically incorrect with the code.
there is no syntax error in writing printf() in between two cases. we can write any of the executable statements in between cases. So it won't gives you any syntax error. But as you write break statement, control will be come out of the switch case (or say immediate case). so whatever is written after break statement, becomes unreachable. and gives you unreachable code warning..
as stated by others the printf command is treated as unreachable code, you can compile the same program using C++ compiler that shows a warning tab indicating all the errors undetectable by syntax analyzer consider the code
int func(int a)
{
int b = a*2;
return b;
// Unreachable code
if (b < 10)
{
b += 10;
}
return b;
}
so it is a logical error not a syntax error detected by the C++ compiler and goes undetected by some older compilers
So here is your original code (I modified it a bit, so it's more complete as a `switch` clause):
// ********************//
int test =1;
switch(test) {
case 1: int a=9; break;
printf("hellooo");
case 2 : int y =98;
printf("kill");
break;
default: // Do something here
}
// ********************//
... I am assuming what troubled you is that the 'hellooo' statement is skipped (when `test = 1`) (?). Here is the reason:
In this statement:
case 1: int a=9; break;
... if `test = 1` set local variable `a` to 9 then break. Therefore, your program is break before it reaches the printf("hellooo") statement, and that's why it's skipped.
Another potential problem from the above statement is `int a=9` (and similarly `int y=98`) are local to the `switch` clause, once you're done with it and exit, those variables are gone (I don't know if this is what you want?).
... To sum up, I've modified like the following, so that 'hellooo' can be printed when test is 1:
// ********************//
int test =1;
switch(test) {
case 1:
int a=9;
printf("hellooo"); // Now, output 'hellooo'
break; // then break
case 2 :
int y =98;
printf("kill");
break;
default:
// handle default here
}
// ********************//
*** You might also want to consider declare `a` and `y` outside the `switch` clause(?)
Hope this would help. Good luck,
Switch / case statements in C don't work the way most people think they do. They are just glorified if-then-else statements. As originally conceived, they had the semantics of the following code. (The following code is perfectly legal C — try it.)
int i = 123;
switch(i) {
case 012: {
printf("012\n");
break;
case 123: {
printf("123\n");
break;
case 456: {
printf("456\n");
break;
default: {
printf("default\n");
break;
}
}
}
}
}
Understanding these semantics is important to some idiomatic C constructs that one finds popping up in Brian Kernighan's code now and then...
switch / case statements are just a more organized or readable way to implement branches. the key of such statements are the labels. there is nothing illegal, according to the C standard, in writing statements between a 'case' and a 'break'. if you disassemble the code generated by something like:
switch(a){
case 5:
....
break;
case 7:
....
break;
default:
}
or the equivalent if / then construction:
if (a == 5){
...
}
if (a == 7){
...
}
...you will notice that the machine code will be basically the same. the switch / case allows you, by definition, to insert 'dead code' in the construction, but there is nothing wrong with that. without the 'break', the program flow would just miss the next label and continue executing code from the next label, without testing for a condition.
Two comments. First, a switch implements a multi-way if-then-else only if a break is added after each case. Otherwise, it implements re-entrant code--a feature used quite frequently in systems programming, where some cases needed initial action, but otherwise were handled just like others. The code continues through case labels until it encounters a break (or the end of the switch). As a very simple
Thomas: I don't think there is anything in the C language that ever defines any code as being re-entrant. Can you cite a section of the standard otherwise?
Better than comparing it to an if-then-else is perhaps to compare it to a computed GOTO in Fortran. Those, too, have fall-through.
Peter: I think the inference of your post leapt far beyond what I presented.
A switch statement is simply syntax to write a jump table: the case labels can be attached to virtually anything, and certainly in earlier versions of C and C++, you could even attach them as follows:
switch (i) {
case 2: for (int j=i; j
printf("hello"); in your case is unreachable because you have a break; statement right after int a=9; which makes this statement the last one to be executed when the evaluation of the expression in your switch matches the case 1. You can replace the break after printf("hello"); if you want it to be executed in case 1.
A switch is more a jump table than an if-then with ; that's why the syntax mirrors labels for case : and the use of break; is needed for separation of code. It is also why cases are not required to be ordered.
One of the more curious uses would be, for instance, putting default at the TOP, falling through, and having other numbers cut off bits of code.
It should assemble to completely different code without optimization than an if-then-else tree; all the code for the tests should front-load any code for the cases. Switches for dense case sets should be implemented as a jump table, with an address to jump to for each integer (this is, IIRC, what is done for the switches generated by GREP)
You code is syntactically correct, however, at the end of the line that contains case 1 you have a break which concludes the execution of the switch statement. Since the printf("hellooo"); command follows the break, it will never be executed.
In order to avoid confusion, I suggest you to properly indent the code:
case 1:
int a=9;
break; // move this break just before the case 2 line
printf("hellooo");
case 2:
int y =98;
printf("kill");
break;
Thomas J. Marlowe is correct that a switch implements a multi-way if-then-else, or the classic pascal CASE structure, only if a break is ued afer each case statement and before the next. Otherwise it implements ehat is essentially a jump table. This can be used to create reentrant code, but does not automatically do so.
From a mere standards perspective your code is "correct": it complies with all syntax and "minimal" (see Jerrold Heyman comment in that regard) semantic requirements, which basically boil to type checking. What you "could", not "should", expect from a compiler is an "unreachable statement" warning.
En passant, there is much that could be criticized, from a programming language design perspective, about the "switch" construct in C. The most notable symptoms of various issues are that: 1) the "case" clauses are little more than labels (as in go to labels), and 2) requiring programmers to "break" appropriately. But we should keep in mind that the "minimalist" (dare I say "hackish") semantic nature of the "switch" construct is consistent with the design goals of the language at inception, in particular being a portable, "low overhead", replacement for programming in assembly. For a classic example supporting that claim, first let's ask ourselves what can we do by omitting (rather than "misplacing") break statements in a switch, and then take a look at the "Duff's device" entry on Wikipedia.
We should put ourselves in the mid 70s context. C made conceivable and reasonable to write (almost) entire operating systems in something at a higher level than assembly code. Kernighan and Ritchie did a great job. To them, we should simply say: "thank you".
C has sometimes been called a "high level assembly language" and the switch statement is a good example of why. Think about what happens when the C compiler turns a switch statement into the corresponding assembly language statements. These assembly statements (a) evaluate the switch's expression and then (b) jump to the corresponding case (or the default: case when there is no match), where execution continues. Cases are just abstractions for assembly language labels. Assembly statements are by default executed sequentially, and label statements are ignored except when they are the target of a jump statement. Break statements are an abstraction for an unconditional jump to the end of the control structure. So when there are no break statements to trigger a jump out of the switch, control proceeds sequentially through its cases; when a break statement is encountered, control jumps to whatever follows the switch statement.
The syntax and semantic rules for a switch statement just require that its contents form valid statements; they do not require that those statements be organized in a way that ensures all are reachable. A user-friendly compiler may generate a warning for you if/when it discovers unreachable code, but it is not an error.
This is not an error for the compiler. The syntax of the switch case doesn't specify that you have to include break statement.
So for your case the "printf("hello")" is considered inside case 1:.
But as you have written break statement it becomes unreachable and won't get printed. (if the case is passed). If you remove break from the case then you should see both the prints (if the case is passed). So indeed compiler is not skipping this step it is compiled correctly its just that it is not throwing warning such as "statement unreachable".
May be if you want to see that warning you can turn on compiler flags for unreachable statements.
Hey ! Interesting observation !
"Switch case" falls under the Selection statement in C Language, which allows user to 'switch' to one of given list of 'cases' that matches , suppose if none of the 'cases' are matching then the control goes to 'default' case. (technically)
In common terms, we can say it functions as a 'electronic switch' that we use @ our home day-to-day. suppose say there are A,B,C switches in the electronic board and you want to switch only the A switch , the control from your mind makes the selection only to the A switch , because your input from mind to the hand is to A.
Switch statements are mostly used for selection / interactive / menu-driven programming which means nothing, you will have a menu of items for the user to select. Thus this improves the interaction between user and the program well.
Proper syntactic usage of switch statement :
switch ( Your_Choice )
{
case Choice_1 :
operation_1;
break;
case Choice_2 :
operation_2;
break;
case Choice_3 :
operation_3;
break;
case Choice_4:
operation_4;
break;
case Choice_5 :
operation_5;
break;
...................
Default :
Default_Operation;
}
Always each case should be terminated by 'break' statement. For better programming each switch statement should be terminated by 'default' case.
But for understanding the syntactic functioning of the switch case statement several varieties were discussed in the class rooms :
for ex :
Example - 1 :
int Choice = 3;
switch (Choice)
{
case 1 :
print 'Hi';
break;
default :
printf("\n Invalid Choice");
}
Example - 2 :
int Choice = 3;
switch (Choice)
{
case 1 :
case 3 :
print 'Hi';
break;
default :
printf("\n Invalid Choice");
}
etc.,
in first example the default part gets executed, where as in second example case 3 gets executed.
But what if the choice is '1', in this case again the case 3 would be followed since there is no break statement at the end of case 1. thus this is a misleading switch case.
and once the control reaches the break statement , the control terminates to '}' end of switch by skipping all the other statements that are below the 'break;'.
Like wise several syntactic puzzles can be created out of switch case just by relocating statements. but majorly this is done to understand.
But the purpose of C ''Switch Case" is to make a selection out the given cases.
There is an unreachable statement (printf("Hellooo";) in your code, thus compiler generates no code for it!. The compiler produces a WARNING message if proper warning level had been set before, and no message if not.
Your example is not too different than the following:
while (a > 5) {
int x = 1;
break;
print("I am unreachable")
}
Would you expect the compiler to throw an error in this case? May be the programmer is debugging and put the break statement there to debug only the top portion of the loop or will fill the part after break afterwards but wanted to put a placeholder (kind of simulating the pass statement in Python). So just a warning will be more appropriate. I know, switch is different but I guess the rationale of not throwing an error for your example is similar to this case.
What makes switch different is that it has an unusual flow and unfortunately its syntax is not very reflective of this aspect. So these kind of confusions arise more easily.
- Badges
- Science topic
- Similar topics
- Computer Science and Engineering
- Programming Languages