why does C standard allow this declaration

[sunny]

Hi

Why does C allows declaration of variable inside switch block.
ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

this prints some garbage.
( yeah even though i got warning msg "unreachabl e code int b = 20" why
is it declaring inside switch block but not initializing b)

[Chris McDonald]

Re: why does C standard allow this declaration

"sunny" <sunny.nls@gmai l.comwrites:

>Why does C allows declaration of variable inside switch block.
>ex: foll prg does not gives "undeclared "b" error msg. but also does
>not initialize b to 20
int a=1;
switch(a)
{
>int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

>this prints some garbage.
>( yeah even though i got warning msg "unreachabl e code int b = 20" why
>is it declaring inside switch block but not initializing b)

Programs do not give warnings about themselves;
different compilers may give different warnings and errors.

You will probably be horrified by Duff's Device:

http://www.lysator.liu.se/c/duffs-device.html#duffs-device

http://www.catb.org/jargon/html/D/Duffs-device.html

--
Chris,

[Tejas Kokje]

Re: why does C standard allow this declaration

sunny wrote:

Hi
>
Why does C allows declaration of variable inside switch block.
ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}
>
this prints some garbage.
( yeah even though i got warning msg "unreachabl e code int b = 20" why
is it declaring inside switch block but not initializing b)

It depends on your compiler. I am using gcc and it throws following
warning message

[kokje@RocketFue l ~]$ gcc test.c -o test
test.c: In function `main':
test.c:7: warning: unreachable code at beginning of switch statement

What compiler are you using ?

Tejas Kokje

[Ancient_Hacker]

Re: why does C standard allow this declaration


sunny wrote:

Hi
>
Why does C allows declaration of variable inside switch block.
ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

this is an unfortunate side efect of allowing declarations at the
beginning of any block, and the switch statement requiring a block, or
at least to be useful;

In general it's not fair to look for extreme sense in C, it was just
supposed to be a pragmatic, ad-hoc language for use by some genius
coders at Bell Labs, 30+ years ago, for hecks sake!

[sunny]

Re: why does C standard allow this declaration

i am using gcc available with Cygwin

Tejas Kokje wrote:

sunny wrote:

Hi

Why does C allows declaration of variable inside switch block.
ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

this prints some garbage.
( yeah even though i got warning msg "unreachabl e code int b = 20" why
is it declaring inside switch block but not initializing b)

>
>
It depends on your compiler. I am using gcc and it throws following
warning message
>
[kokje@RocketFue l ~]$ gcc test.c -o test
test.c: In function `main':
test.c:7: warning: unreachable code at beginning of switch statement
>
What compiler are you using ?
>
Tejas Kokje

[mark_bluemel@pobox.com]

Re: why does C standard allow this declaration


sunny wrote:

Hi
>
Why does C allows declaration of variable inside switch block.

because it allows declaration of variables inside any braced block.

ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}
>
this prints some garbage.
( yeah even though i got warning msg "unreachabl e code int b = 20" why
is it declaring inside switch block but not initializing b)

automatic variables (of which b is an example) are initialized as if by
an assignment (I'm talking casually here).

So it's as if the block starts with :-
{
int b; /* declaration */
b = 20; /* initialization */
case 1: <etc>

But in a switch statement only the operations following "case" or
"default" are executed. Hence the variable b is declared, but not
initialized.

[jmcgill]

Re: why does C standard allow this declaration

Chris McDonald wrote:

You will probably be horrified by Duff's Device:

I'm not so much horrified as puzzled by the location of the while.
Is it the equivalent of a goto into a do loop?

[mark_bluemel@pobox.com]

Re: why does C standard allow this declaration


sunny wrote:

Hi
>
Why does C allows declaration of variable inside switch block.

I went back to my dog-eared copy of K & R (1st edition).

On P.203 it says "Declaratio ns may appear at the head of [the subject
of a switch], but initializations of automatic and register variables
are ineffective".

So one answer to "why?" is "because that's what K & R said".

[A. Bolmarcich]

Re: why does C standard allow this declaration

On 2006-09-20, sunny <sunny.nls@gmai l.comwrote:

Hi
>
Why does C allows declaration of variable inside switch block.
ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}
>
this prints some garbage.
( yeah even though i got warning msg "unreachabl e code int b = 20" why
is it declaring inside switch block but not initializing b)

As the warning message stated, the initialization is unreachable code.
According to the specification:

Storage is guaranteed to be reserved for a new instance of such an
object on each normal entry into the block with which it is associated,
or on a jump from outside the block to a labeled statement in the
block or in an enclosed block. If any initialization is specified for
the value stored in the object, it is performed on each normal entry,
but not if the block is entered by a jump to a labeled statement.

The compiler is conforming to the specification, and it is giving a
warning about the initialization not being performed.

[lovecreatesbea...@gmail.com]

Re: why does C standard allow this declaration

mark_bluemel@po box.com wrote:

sunny wrote:
>

Hi

Why does C allows declaration of variable inside switch block.

>
because it allows declaration of variables inside any braced block.

Old C doesn't allow variables to be declared everywhere, right?

ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

this prints some garbage.
( yeah even though i got warning msg "unreachabl e code int b = 20" why
is it declaring inside switch block but not initializing b)

>
automatic variables (of which b is an example) are initialized as if by
an assignment (I'm talking casually here).
>
So it's as if the block starts with :-
{
int b; /* declaration */
b = 20; /* initialization */
case 1: <etc>
>
But in a switch statement only the operations following "case" or
"default" are executed. Hence the variable b is declared, but not
initialized.

Your explanation seems reasonable. The control flow goes to "int b;"
and "b" is defined. It also goes to "b = 20;", why doesn't the
assignment take effect?

What's the difference between a declaration and a statement? When does
the declaration is executed and the variable "b" is defined? Why does
the assignment statement above is skipped but the declaration is not?

Thank you.

[Frederick Gotham]

Re: why does C standard allow this declaration

lovecreatesbea. ..@gmail.com posted:

mark_bluemel@po box.com wrote:

>sunny wrote:
>>

Hi
>
Why does C allows declaration of variable inside switch block.

>>
>because it allows declaration of variables inside any braced block.

>
Old C doesn't allow variables to be declared everywhere, right?

No, all declarations must appear at the beginning of a block, before any
expression statements.

What's the difference between a declaration and a statement?

A declaration declares something. Here are some examples of declarations:

int i;
typedef unsigned UInt;
int Func();

(the first one is a definition as well as a declaration.)

--

Frederick Gotham

[Christopher Benson-Manica]

Re: why does C standard allow this declaration

lovecreatesbea. ..@gmail.com <lovecreatesbea uty@gmail.comwr ote:

{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

Your explanation seems reasonable. The control flow goes to "int b;"
and "b" is defined. It also goes to "b = 20;", why doesn't the
assignment take effect?

The control flow does *not* go to b=20; read other replies in this
thread, or look at the example in n869 6.8.4.2, paragraph 7.

--
C. Benson Manica | I *should* know what I'm talking about - if I
cbmanica(at)gma il.com | don't, I need to know. Flames welcome.

[Keith Thompson]

Re: why does C standard allow this declaration

"sunny" <sunny.nls@gmai l.comwrites:

Why does C allows declaration of variable inside switch block.
ex: foll prg does not gives "undeclared "b" error msg. but also does
not initialize b to 20
int a=1;
switch(a)
{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}
>
this prints some garbage.
( yeah even though i got warning msg "unreachabl e code int b = 20" why
is it declaring inside switch block but not initializing b)

The C switch statement is actually a rather primitive construct. It's
basically nothing more than a computed goto statement.

The code above is equivalent to this:

int a=1;
if (a == 1) goto case_1; else goto case_default; /* switch(a) */
{
int b=20;
case_1:
printf("b is %d\n",b);
goto end_of_switch; /* break; */
case_default: printf("b is %d\n",b);
goto end_of_switch; /* break; */
}
end_of_switch:;

The grammar doesn't even require a block; it's just
switch ( expression ) statement

For example here's a rather perverse "hello, world" program:

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

You *can* write structured switch statements if you're careful. You
can also write impenetrable spaghetti. Or you can write Duff's
Device, which is a little of each.

--
Keith Thompson (The_Other_Keit h) kst-u@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[lovecreatesbea...@gmail.com]

Re: why does C standard allow this declaration


Christopher Benson-Manica wrote:

lovecreatesbea. ..@gmail.com <lovecreatesbea uty@gmail.comwr ote:
>

{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

>

Your explanation seems reasonable. The control flow goes to "int b;"
and "b" is defined. It also goes to "b = 20;", why doesn't the
assignment take effect?

>
The control flow does *not* go to b=20; read other replies in this
thread, or look at the example in n869 6.8.4.2, paragraph 7.

I understand that the control flow will go to one of the "case" and
"default" entries in the following example. The code lines 4 and 5 are
not in any of those entries.

Code line 4 & 5 are in the same scope. I want to know why the variable
"b" is defined at line 4 but the assignment at line 5 is skipped. When
are declaration and statement executed respectively? Is declaration
executed at compiling time but statement executed at run-time?

Thank you.

....
{
int b; /*line 4*/
b=20; /*line 5*/

case 1:
printf("b is %d\n",b);
break;
default:
printf("b is %d\n",b);
break;
}

[Jack Klein]

Re: why does C standard allow this declaration

On 20 Sep 2006 18:59:34 -0700, "lovecreatesbea ...@gmail.com"
<lovecreatesbea uty@gmail.comwr ote in comp.lang.c:

>
Christopher Benson-Manica wrote:

lovecreatesbea. ..@gmail.com <lovecreatesbea uty@gmail.comwr ote:

{
int b=20;
case 1: printf("b is %d\n",b);
break;
default:printf( "b is %d\n",b);
break;
}

Your explanation seems reasonable. The control flow goes to "int b;"
and "b" is defined. It also goes to "b = 20;", why doesn't the
assignment take effect?

The control flow does *not* go to b=20; read other replies in this
thread, or look at the example in n869 6.8.4.2, paragraph 7.

>
I understand that the control flow will go to one of the "case" and
"default" entries in the following example. The code lines 4 and 5 are
not in any of those entries.
>
Code line 4 & 5 are in the same scope. I want to know why the variable
"b" is defined at line 4 but the assignment at line 5 is skipped. When
are declaration and statement executed respectively? Is declaration
executed at compiling time but statement executed at run-time?
>
Thank you.
>
...
{
int b; /*line 4*/
b=20; /*line 5*/
>
case 1:
printf("b is %d\n",b);
break;
default:
printf("b is %d\n",b);
break;
}

An assignment statement is like any other statement. It is executed
when the control flow of the program "passes through" that statement.

Consider this snippet:

int silly_func(int x)
{
int y = 0;

if (x < -10)
{
y = -1;
}
else if (x 10)
{
y = 1;
}
return y;
}

The first line inside the brace is a declaration with an initializer,
so y is always initialized to 0 at the start of the function. As to
the two assignment statements, either the first, the second, or
neither of them will be executed. The control flow of the program
does not "pass through" a statement that is controlled by a
conditional expression that happens to be false.

This is not just a property of the braces that I used after the "if"
and "else if". You could remove them and result would be the same.
Nor is it a special property of "if" and other conditional statements.

Look at this similar (in result) example:

int sillier_func(in t x)
{
int y = 0;

if (x < -10)
goto negative;

if (x 10)
goto positive;

goto all_done;

negative:
y = -1;
goto all_done;

positive:
y = 1;

all_done:
return y;
}

This function must perform exactly the same as the first. If y is
between -11 and INT_MIN, it must return -1. If y is between 11 and
INT_MAX, it must return 1. Otherwise, y is between -10 and +10
inclusive, and the function returns 0.

Here the assignments are at the same level, which also happens to be
the same level as the declaration and initializer. But the goto
statements cause just one, or neither, of the assignment statements to
be initialized.

When the flow of control goes "around", instead of "through" a
statement, that statement is not executed.

This also applies to declarations with initializers, although
technically an initializer is not a statement. If the flow of control
goes "around", rather than "through" a declaration with an
initializer, which can only happen in a switch statement, the object
has scope through the end of the block, but is not initialized either.

Note that if you did this in a switch statement:

switch (x)
{
int b = 0;
case 1: printf("b = %d\n", b); break;
}

....you produce undefined behavior when x is 1 because b is an
uninitialized automatic variable.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++

http://www.contrib.andrew.cmu.edu/~ajo/docs/FAQ-acllc.html