Question on switch block scope

[Minti]

I was reading some text and I came across the following snippet

switch('5')
{
int x = 123;
case '5':
printf("The value of x %d\n", x);
break;
}
Now according to the text the memory would be allocated for the varible x but

the value of x would be an intermediate one. Can anybody expain the rationale

for this I ran this snippet [ with the obvious additions] through a C++

compiler and it gave me an error for this the following definition

int x = 123;

Is this sort of behavior of any use?

I could have better done through

{
int x = 123;
switch('5') {
....
}
}

But I was just wondering as to even declaring a variable in the switch level

scope should be allowed?

--
FUCK SCO!
Imanpreet Singh Arora
isingh AT acm DOT org
Even if you are on the right track you are going to get run over if you just
keep sitting there . - Will Rogers

[Sheldon Simms]

On Fri, 14 Nov 2003 10:34:04 +0530, sahukar praveen wrote:

The contents below the header "6.8#3" seems to be an extract from some
standard document. Could you
please provide me more details about the document and the location where I
can get it.

Ben already gave you the long answer. The short answer is

http://webstore.ansi.org/ansidocstor...EC+9899%2D1999

[Minti]

Sheldon Simms <sh**********@y ahoo.com> wrote in message news:<pa******* *************** ******@yahoo.co m>...

On Thu, 13 Nov 2003 12:26:59 -0800, Minti wrote:

I was reading some text and I came across the following snippet

switch('5')
{
int x = 123;
case '5':
printf("The value of x %d\n", x);
break;
}
Now according to the text the memory would be allocated for the varible x but
the value of x would be an intermediate one. Can anybody expain the rationale

The assignment of 123 to x never happens
The code is equivalent to:

goto foo;
{
int x = 123;
foo:
printf("The value of x %d\n", x);
}

Thanks Sheldon, but could you tell me when is the memory for x
allocated. If it has to be allocated when we get into the block after
the statement

goto foo;

Then obviously we can't use x at any place. Or is it the case that
that space would be reserved for x, or any other variable within the
immediate scope of the switch block but it's value would not be
initialized for the given initialization value.
--

Imanpreet Singh Arora
isingh AT acm DOT org

[Sheldon Simms]

On Fri, 14 Nov 2003 12:10:06 -0800, Minti wrote:

Sheldon Simms <sh**********@y ahoo.com> wrote in message news:<pa******* *************** ******@yahoo.co m>...

goto foo;
{
int x = 123;
foo:
printf("The value of x %d\n", x);
}

Thanks Sheldon, but could you tell me when is the memory for x
allocated. If it has to be allocated when we get into the block after
the statement

goto foo;

Then obviously we can't use x at any place. Or is it the case that
that space would be reserved for x, or any other variable within the
immediate scope of the switch block but it's value would not be
initialized for the given initialization value.

We don't know or care when space for the object named x is reserved,
but we know that x is in scope and accessible from the point of its
declaration to the end of the block in which it is declared. The
C Standard puts it like this:

6.2.1
2 For each different entity that an identifier designates, the
identifier is visible (i.e., can be used) only within a region
of program text called its scope.

4 If the declarator or type specifier that declares the identifier
appears inside a block ... the identifier has block scope, which
terminates at the end of the associated block.

This means that we can use x anywhere inside the block after it is
declared, regardless of whether or not it has been initialized. It
does not mean that our use of x has defined behavior.

-Sheldon

[CBFalconer]

Dan Pop wrote:

CBFalconer <cb********@yah oo.com> writes:

Alan Balmer wrote:

... snip ...

Is this not a declaration with initialization, rather than an
assignment?

Contrary to external appearances, there is no such declaration for
automatic variables.

Of course there is:

int x;

at block scope.

Code must always be generated to perform the initialization.

Nonsense. The compiler merely has to allocate space for x on a
stack-like data structure, without touching this space. The program
can assign something to x at any time before trying to access its value
for the first time. If this something is not available at the time the
variable is defined, there is no point in providing an initialiser.

We are not even disagreeing. Your example is a declaration with
no initialization statement. I was talking about declarations
with initialization statements, and whether they generate code.
Because they do, there is really no such thing.

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Minti]

Eric Sosman <Er*********@su n.com> wrote in message news:<3F******* ********@sun.co m>...

Minti wrote [reformatted for better line length and spacing]:

I was reading some text and I came across the following snippet

switch('5')
{
int x = 123;
case '5':
printf("The value of x %d\n", x);
break;
}
Now according to the text the memory would be allocated for the varible x
but the value of x would be an intermediate one. Can anybody expain the
rationale for this

Which "this" do you mean? Why `x' is indeterminate,
or why the code was written this way?

The value of `x' is indeterminate because the `switch'
statement jumps directly to the selected `case' or `default'.
The executable code that sets `x' equal to 123 cannot be
reached, and thus is not executed.

The programmer's reason for attempting this construct
is a mystery I am unable to explain. Perhaps his or her
grasp of C was not very firm.

I could have better done through

{
int x = 123;
switch('5') {
....
}
}

That is fine; you have cured the indeterminacy.

But I was just wondering as to even declaring a variable in the switch
level scope should be allowed?

Variable declarations are permitted at the start of
*any* {}-enclosed executable block. There is nothing special
about `switch' in this regard.

Is the technique useful? Yes, it can be. If a block
is the only user of some particular variable, it may be
a good idea to limit the variable's scope to the block.
This can emphasize to the human reader that the variable
has no significance outside the block, and may also help
the compiler discover when the variable has "died" so it
can re-use the registers or other resources that held it.

That is why I suggested a little alternative to to just the part of
declaring variable[s] within a {} that encloses the switch block, my
main reason for asking the question was since

int x = 32;

is a declaration with initialization I was confused why the
declaration would only be 'executed' i.e. why only the memory for x
would be allocated but not initialized even though they form one
single statement.

<snip>

--

Imanpreet Singh Arora
isingh AT acm DOT org

[Kevin Bracey]

In message <pa************ *************** *@yahoo.com>
Sheldon Simms <sh**********@y ahoo.com> wrote:

On Fri, 14 Nov 2003 12:10:06 -0800, Minti wrote:

Sheldon Simms <sh**********@y ahoo.com> wrote in message news:<pa******* *************** ******@yahoo.co m>...

goto foo;
{
int x = 123;
foo:
printf("The value of x %d\n", x);
}

Thanks Sheldon, but could you tell me when is the memory for x
allocated. If it has to be allocated when we get into the block after
the statement

goto foo;

Then obviously we can't use x at any place. Or is it the case that
that space would be reserved for x, or any other variable within the
immediate scope of the switch block but it's value would not be
initialized for the given initialization value.

We don't know or care when space for the object named x is reserved,
but we know that x is in scope and accessible from the point of its
declaration to the end of the block in which it is declared.

I think we do care, although not in this example. Minti's question is
answered by distinguishing the "lifetime" from the "scope".

x's lifetime extends from the start of its enclosing block to the end. Thus
in the following example:

int *p = NULL;
{
label:
if (p) printf("x = %d\n", *p);

int x = 5;

printf("x = %d\n", x);

x = 10;

if (!p)
{
p = &x;
goto label;
}
}

You will get the output

x = 5
x = 10
x = 5

Although x isn't in scope at the first printf, it still exists, and you
can reference it through the pointer p.

So, from the abstract machine's point of view, x is "allocated" , but
uninitialised when the { } block is entered and "deallocate d" when the block
is exited. It is initialised (or re-initialised) whenever execution reaches
its declaration/initialiser.

An actual implementation does not have to actually "allocate" or "deallocate "
x there - it may reserve space for it on function entry, for example,
regardless of whether the block is entered. But that's not the C programmer's
business. For you, the scope extends from the declaration to the end of the
block, and the lifetime from block entry to block exit.

PS - never write code like that
PPS - the example is C99
PPPS - a worse example is in the C99 rationale

--
Kevin Bracey, Principal Software Engineer
Tematic Ltd Tel: [phone]
182-190 Newmarket Road Fax: [phone]
Cambridge, CB5 8HE, United Kingdom WWW: http://www.tematic.com/

[Kevin P. Fleming]

Kevin Bracey wrote:

An actual implementation does not have to actually "allocate" or "deallocate "
x there - it may reserve space for it on function entry, for example,
regardless of whether the block is entered. But that's not the C programmer's
business. For you, the scope extends from the declaration to the end of the
block, and the lifetime from block entry to block exit.

I don't follow this; if 'x' was not in scope in the first line of the
block (because the declaration was two lines later), then references to
'x' at that point would have to resolve to some _other_ declaration of
'x' that _is_ in scope, not the one in this block. The example you gave
showed that both the lifetime _and_ the scope of x are the entire
enclosing block.

[Kevin Bracey]

In message <V7Nub.18630$vJ 6.6629@fed1read 05>
"Kevin P. Fleming" <kp*******@cox. net> wrote:

Kevin Bracey wrote:

An actual implementation does not have to actually "allocate" or
"deallocate " x there - it may reserve space for it on function entry, for
example, regardless of whether the block is entered. But that's not the C
programmer's business. For you, the scope extends from the declaration to
the end of the block, and the lifetime from block entry to block exit.
I don't follow this; if 'x' was not in scope in the first line of the
block (because the declaration was two lines later), then references to
'x' at that point would have to resolve to some _other_ declaration of
'x' that _is_ in scope, not the one in this block.

Indeed, they would.
The example you gave showed that both the lifetime _and_ the scope of x
are the entire enclosing block.

I don't think so. No, the first printf accessed x through a pointer
which was in scope:

if (p) printf("x = %d\n", *p);

If I'd just written

printf("x = %d\n", x);

that would have been an error, or the wrong x would have been used.

--
Kevin Bracey, Principal Software Engineer
Tematic Ltd Tel: [phone]
182-190 Newmarket Road Fax: [phone]
Cambridge, CB5 8HE, United Kingdom WWW: http://www.tematic.com/

[Kevin P. Fleming]

Kevin Bracey wrote:

I don't think so. No, the first printf accessed x through a pointer
which was in scope:

if (p) printf("x = %d\n", *p);

If I'd just written

printf("x = %d\n", x);

that would have been an error, or the wrong x would have been used.

OK, yeah, I missed that subtlety. Well, actually I saw it, but my brain
passed it off as irrelevant. It wasn't :-)