declaration of variable in for loop

[poornimamprabhu]

Hi there,

suppose i have piece of code like
main()
{
int i,j;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
}
}
When i see the address of K its same in all iterations.That means K is
only defined once at a time.
Is it because each for loop execution is considered as separte
block,its allocating in the same address?
or is it allocated memory only once?

[Walter Roberson]

In article <05************ *************** *******@f10g200 0hsf.googlegrou ps.com>,
<po************ *@gmail.comwrot e:

>suppose i have piece of code like
main()
{
int i,j;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
}
}

>When i see the address of K its same in all iterations.That means K is
only defined once at a time.
Is it because each for loop execution is considered as separte
block,its allocating in the same address?
or is it allocated memory only once?

The answer is compiler dependant. C does not define when or where
memory allocation is made for automatic variables: it only
defines rules for when storage is meaningfully accessible, and
rules about which declaration of a name is the one denoted by
a mention of the name.

In some compilers the answer would be "neither of the above".
For example some compilers allocate automatic variables from
a heap, so the fact that the variable showed up with a particular
address in each iteration could just reflect the fact that no
unreleased heap allocations were made between iterations of the loop.

--
"Is there any thing whereof it may be said, See, this is new? It hath
been already of old time, which was before us." -- Ecclesiastes

[DDD]

On Jan 31, 2:25 pm, poornimampra... @gmail.com wrote:

Hi there,

suppose i have piece of code like
main()
{
int i,j;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
}

}

When i see the address of K its same in all iterations.That means K is
only defined once at a time.
Is it because each for loop execution is considered as separte
block,its allocating in the same address?
or is it allocated memory only once?

because each for loop execution is considered as separte block. And
the memory address of K should be random.

[santosh]

po************* @gmail.com wrote:

Hi there,

suppose i have piece of code like

Include stdio.h here.

main()

int main(void) is better form.

{
int i,j;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);

You probably want:

printf("%d\t%p = %d\n", i, (void *)&k, k);

The 'p' format specifier expects a void * value and the type of the
value yielded by the address-of operator is "pointer to T" where T is
the type of it's operand. Also the '*' character in your format string
specifies that the following formatting operation be of the minimum
field width specified by the corresponding argument to '*'. In this
case it is the fourth printf() argument and thus, the final 'd'
specifier is left without an argument, invoking undefined behaviour.

}
}
When i see the address of K its same in all iterations.That means K is
only defined once at a time.
Is it because each for loop execution is considered as separte
block,its allocating in the same address?
or is it allocated memory only once?

This is implementation dependant. You cannot rely on the address of 'k'
being the same across iterations. However the compiler is very likely
to "optimise" in such cases and create and destroy 'k' only once for
the entire duration of the loop. But you cannot rely on such behaviour.

[Mark Bluemel]

po************* @gmail.com wrote:

Hi there,

suppose i have piece of code like
main()
{
int i,j;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
}
}
When i see the address of K its same in all iterations.That means K is
only defined once at a time.

I don't understand what you mean by "once at a time"

Is it because each for loop execution is considered as separte
block,its allocating in the same address?
or is it allocated memory only once?

Who knows? More importantly, who cares?

1) The compiler's optimisation routines could have determined
that there was no need for k to be in the nested block and
moved it out
2) The management of memory at run time could (very likely would,
I suspect) mean that the same address was allocated each time
through the loop
3) There may be some other explanation

None of this behaviour is guaranteed by the standard, and it is
far from certain that it would be the same in another environment.

Why are you bothered about how the compiler has organised things?

[Kaz Kylheku]

On Jan 30, 10:25*pm, poornimampra... @gmail.com wrote:

Hi there,

suppose i have *piece of code like
main()
{
* * * * int i,j;
* * * * for(i=0;i<10;i+ +){
* * * * * * * * * * * * int k = i;
* * * * * * * * * * * * printf("%d * *%p = *%d\n",i,&k,k);
* * * * }

}

When i see the address of K its same in all iterations.That means K is
only defined once at a time.
Is it because each for loop execution is considered as separte
block,its allocating in the same address?
or is it allocated memory only once?

There is also this possibility: the address of k was produced only
because you asked for it with the & operator, and the existence of
this address doesn't prove that the value of k is actually ever stored
there.

[jacob navia]

po************* @gmail.com wrote:

Hi there,

suppose i have piece of code like
main()
{
int i,j;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
}
}
When i see the address of K its same in all iterations.That means K is
only defined once at a time.

For some compilers like lcc-win this is the case.
lcc-win allocates all local variables of the function, no
matter what scope, at the start of the function. The stack is not
modified within the function. This is done for obvious
performance reasons. Imagine that at the end of the
block the stack was adjusted, and at the start space
for the variable would be created. This would make for
at least 2 instructions per block iteration... not a good
idea.

Of course, the *scope* of the variable is ONLY within the
enclosing block. After the block is left, there is no way to access
that stack position within C, unless you take
the address of the local variable.

main()
{
int i,j, *pint;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
pint=&i;
}
*pint = 789; // Accessing illegal storage
}

This would work on lcc-win since the storage is still valid.
I would not do this since it is absolutely non portable.
Other compilers could implement other strategies.

For instance
main()
{
int i,j;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
}
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
}
}
The second "k" could be aliased by the compiler to the first one
and stored at the same memory location.

Is it because each for loop execution is considered as separte
block,its allocating in the same address?
or is it allocated memory only once?

For lcc-win it is the second.

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

[santosh]

jacob navia wrote:

<snip>

main()
{
int i,j, *pint;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
pint=&i;
}
*pint = 789; // Accessing illegal storage
}

This would work on lcc-win since the storage is still valid.
I would not do this since it is absolutely non portable.
Other compilers could implement other strategies.

I hope as a QoI issue lcc-win issues a diagnostic for such uses?

<snip>

[jacob navia]

Mark L Pappin wrote:

jacob navia <ja***@nospam.c omwrites:

>main()
{
int i,j, *pint;
for(i=0;i<10;i+ +){
int k = i;
printf("%d %p = *%d\n",i,&k,k);
pint=&i;
}
*pint = 789; // Accessing illegal storage

What's illegal about it?

If the last statement inside the loop body had instead been
pint=&k;
then you might have a point.

mlp

Yes, I mistyped the name of the variable

Thanks
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

[Walter Roberson]

In article <fn**********@a ioe.org>, santosh <sa*********@gm ail.comwrote:

>po************ *@gmail.com wrote:

> printf("%d %p = *%d\n",i,&k,k);

>You probably want:

printf("%d\t%p = %d\n", i, (void *)&k, k);

>Also the '*' character in your format string
specifies that the following formatting operation be of the minimum
field width specified by the corresponding argument to '*'. In this
case it is the fourth printf() argument and thus, the final 'd'
specifier is left without an argument, invoking undefined behaviour.

That only applies if the * follows the %. Outside of a % specifier,
an * represents the literal character '*'.
--
"Beware of bugs in the above code; I have only proved it correct,
not tried it." -- Donald Knuth