Lori Fairhead <lorif32768@gmail.com> writes:
[...]
> Just think of it as FOR parameters DO command
>
> Each time the paramters tell FOR to execute the command
>
> In this case the command is a BLOCK so the block is executed
> again and again for each iteration of the FOR loop.
>
> You can have a BLOCK anywhere you have a command like several other
> languages.

It's helpful to use the standard terminology. C has *statements*, not
*commands*.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

Barry Schwarz <schwarzb@delq.com> writes:
> On Sat, 23 Apr 2022 13:26:56 -0400, Richard Damon
> <Richard@Damon-Family.org> wrote:
>
>>The key difference between
>>
>>int x = 10;
>>
>>and
>>
>>int x;
>>x = 10;
>>
>>is that the first INITIALIZES x when it is created, and the second
>>ASSIGNS it when the statement is executed.
>>
>>When we change that to
>>
>>static int x = 10;
>>
>>Then by the rules of the C language, that initialization will only
>>happen the first time that we reach that statement, as after that the
>>variable has already been created, so it isn't initiialized again.
>>
>>In fact, behind the scenes, there needs to be some other hidden flag
>>created by the implementation to know if initialization has happened.
>
> I disagree. Paragraph 5.1.2 of C11 explicitly states that a static
> variable is initialized prior to program start up.

Right -- and that's possible because the initializer for a static object
has to be constant.

> The key difference between "int x" (or "int x=10") and "static int x"
> (with or without explicit initialization) is that during execution the
> former causes the variable to be created (and initialized if
> specified) while the latter does absolutely nothing since the variable
> has already been created and initialized.
>
> A hidden flag is not needed at all.

Right.

<OT> C++ allows static objects to have non-constant initialization, so
it does have to ensure that the initialization happens only the first
time the declaration is encountered. A hidden flag is the obvious way
to implement that behavior. </OT>

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

On 4/23/2022 10:26 AM, Richard Damon wrote:
>
> When we change that to
>
> static int x = 10;
>
> Then by the rules of the C language, that initialization will only
> happen the first time that we reach that statement, as after that the
> variable has already been created, so it isn't initiialized again.

No. This sounds like a rule from C++ language. C is not C++.

In C language static initialization is always done "prior to program
startup" (as the Standard says in 6.2.4/3).

This is, BTW, why static initializers in C are required to be constant
expressions.

--
Best regards,
Andrey Tarasevich

On 4/23/22 6:36 PM, Keith Thompson wrote:
> Barry Schwarz <schwarzb@delq.com> writes:
>> On Sat, 23 Apr 2022 13:26:56 -0400, Richard Damon
>> <Richard@Damon-Family.org> wrote:
>>
>>> The key difference between
>>>
>>> int x = 10;
>>>
>>> and
>>>
>>> int x;
>>> x = 10;
>>>
>>> is that the first INITIALIZES x when it is created, and the second
>>> ASSIGNS it when the statement is executed.
>>>
>>> When we change that to
>>>
>>> static int x = 10;
>>>
>>> Then by the rules of the C language, that initialization will only
>>> happen the first time that we reach that statement, as after that the
>>> variable has already been created, so it isn't initiialized again.
>>>
>>> In fact, behind the scenes, there needs to be some other hidden flag
>>> created by the implementation to know if initialization has happened.
>>
>> I disagree. Paragraph 5.1.2 of C11 explicitly states that a static
>> variable is initialized prior to program start up.
>
> Right -- and that's possible because the initializer for a static object
> has to be constant.
>
>> The key difference between "int x" (or "int x=10") and "static int x"
>> (with or without explicit initialization) is that during execution the
>> former causes the variable to be created (and initialized if
>> specified) while the latter does absolutely nothing since the variable
>> has already been created and initialized.
>>
>> A hidden flag is not needed at all.
>
> Right.
>
> <OT> C++ allows static objects to have non-constant initialization, so
> it does have to ensure that the initialization happens only the first
> time the declaration is encountered. A hidden flag is the obvious way
> to implement that behavior. </OT>
>

That might be what I am remembering.

For code like:

int f(int x) {
static int y = x;
return x-y;
}

The initialization for y, needs to be delayed until the first call to f,
so needs a flag.

On Sat, 23 Apr 2022 21:08:44 +0100, Sams Lara <samlara622@gmail.com>
wrote:

>On 23/04/2022 20:49, Barry Schwarz wrote:
>> while the latter does absolutely nothing since the variable
>> has already been created and initialized.
>>
>>
>In other words no memory is allocated at this stage.

Because the memory has already been allocated.

--
Remove del for email

On Saturday, April 23, 2022 at 11:27:53 PM UTC+1, Keith Thompson wrote:
> Lori Fairhead <lorif...@gmail.com> writes:
> [...]
> > Just think of it as FOR parameters DO command
> >
> > Each time the paramters tell FOR to execute the command
> >
> > In this case the command is a BLOCK so the block is executed
> > again and again for each iteration of the FOR loop.
> >
> > You can have a BLOCK anywhere you have a command like several other
> > languages.
> It's helpful to use the standard terminology. C has *statements*, not
> *commands*.
>
Well, whatever, I did say "Just think of it as.. ". Trying to clarify the *idea* not even
just C but generally to aid the OP

Anyhow I was also going to add that this was quite a logical concept
which got me thinking but I need to get a new copy of the C standard
to revise it... about just how logical C was but clang here does compile

int v;
v=printf("hello");
for(;v<100;v++) 2;

unlike some other language a block does not return a value

REGARDS LF

> --
> Keith Thompson (The_Other_Keith) Keith.S.T...@gmail.com
> Working, but not speaking, for Philips
> void Void(void) { Void(); } /* The recursive call of the void */

Lori Fairhead <lorif32768@gmail.com> writes:
> On Saturday, April 23, 2022 at 11:27:53 PM UTC+1, Keith Thompson wrote:
>> Lori Fairhead <lorif...@gmail.com> writes:
>> [...]
>> > Just think of it as FOR parameters DO command
>> >
>> > Each time the paramters tell FOR to execute the command
>> >
>> > In this case the command is a BLOCK so the block is executed
>> > again and again for each iteration of the FOR loop.
>> >
>> > You can have a BLOCK anywhere you have a command like several other
>> > languages.
>> It's helpful to use the standard terminology. C has *statements*, not
>> *commands*.
>>
> Well, whatever, I did say "Just think of it as.. ". Trying to clarify the *idea* not even
> just C but generally to aid the OP

If the OP is going to be programming in C, they will benefit greatly
from being able to communicate clearly about it. The term "statement"
is unambiguous. "Command" is not, and is likely to cause confusion.

> Anyhow I was also going to add that this was quite a logical concept
> which got me thinking but I need to get a new copy of the C standard
> to revise it... about just how logical C was but clang here does compile
>
> int v;
> v=printf("hello");
> for(;v<100;v++) 2;

Yes, that's perfectly valid code. C doesn't prevent you from writing
valid code that doesn't do anything useful. (I don't know of any
language that does, though most languages are more restrictive than C.)

Any expression followed by a semicolon is a valid statement. The
expression is evaluated, and its result is discarded. Normally the
expression will have side effects (for example an assignment expression
or a function call), but there's no requirement that it must.

Having said that, compilers will typically warn about statements with no
effect. Both gcc and clang will do so with the right options.

> unlike some other language a block does not return a value
>
> REGARDS LF

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

Richard Damon wrote:
> On 4/23/22 6:36 PM, Keith Thompson wrote:
> > Barry Schwarz <schwarzb@delq.com> writes:
> > > Richard Damon <Richard@Damon-Family.org> wrote:
> > > >
> > > > [...]
> > > > static int x = 10;
> > > >
> > > > Then by the rules of the C language, that initialization will only
> > > > happen the first time that we reach that statement, as after that the
> > > > variable has already been created, so it isn't initiialized again.
> > > >
> > > > In fact, behind the scenes, there needs to be some other hidden flag
> > > > created by the implementation to know if initialization has happened.
> > >
> > > I disagree. Paragraph 5.1.2 of C11 explicitly states that a static
> > > variable is initialized prior to program start up.
> >
> > Right -- and that's possible because the initializer for a static object
> > has to be constant.
> >
> > > The key difference between "int x" (or "int x=10") and "static int x"
> > > (with or without explicit initialization) is that during execution the
> > > former causes the variable to be created (and initialized if
> > > specified) while the latter does absolutely nothing since the variable
> > > has already been created and initialized.
> > >
> > > A hidden flag is not needed at all.
> >
> > Right.
> >
> > <OT> C++ allows static objects to have non-constant initialization, so
> > it does have to ensure that the initialization happens only the first
> > time the declaration is encountered. A hidden flag is the obvious way
> > to implement that behavior. </OT>
>
> That might be what I am remembering.
>
> For code like:
>
> int f(int x) {
> static int y = x;
> return x-y;
> }
>
> The initialization for y, needs to be delayed until the first call to
> f, so needs a flag.

According to C11 Paragraph 5.1.2, the variable must already be
initialized when f() is called for the first time (at program startup,
see above).

Even if I see no explicit statement in C11, that the initializer must
be constant, using variable x is not possible because the value of x
may be unknown at program startup.

If I try to compile your code above, the compiler says:
|
| error: initializer element is not constant

sobota, 23 kwietnia 2022 o 21:49:51 UTC+2 Barry Schwarz napisał(a):
> On Sat, 23 Apr 2022 13:26:56 -0400, Richard Damon
> <Ric...@Damon-Family.org> wrote:
>
> >The key difference between
> >
> >int x = 10;
> >
> >and
> >
> >int x;
> >x = 10;
> >
> >is that the first INITIALIZES x when it is created, and the second
> >ASSIGNS it when the statement is executed.
> >
> >When we change that to
> >
> >static int x = 10;
> >
> >Then by the rules of the C language, that initialization will only
> >happen the first time that we reach that statement, as after that the
> >variable has already been created, so it isn't initiialized again.
> >
> >In fact, behind the scenes, there needs to be some other hidden flag
> >created by the implementation to know if initialization has happened.
> I disagree. Paragraph 5.1.2 of C11 explicitly states that a static
> variable is initialized prior to program start up.
>
> The key difference between "int x" (or "int x=10") and "static int x"
> (with or without explicit initialization) is that during execution the
> former causes the variable to be created (and initialized if
> specified) while the latter does absolutely nothing since the variable
> has already been created and initialized.
>
> A hidden flag is not needed at all.
>

in fact when i thinked of it it showed to me that behaviour of
static int x = 10; may be understood - as realization what initialisation is and what
static is
behaviour of int x = 10; in loop hovever comes probably from different point it is practical
usability (i am not sure though, int x = 10 done to restet to 10 each time is usable but
im not sure how int x = 10 which not resets is usable)
in fact if you want in loop make x that is initialised once and then reset it you could put
int x = 10; if that would only initialize once and x = 10 when you need reset
in form as it is now if im not wrong you cant do it becouse you cant put initialisation
in loop that only assign once, so you need to put it before whole loop which is definitivly bad

see

while(x<100)
{ int x = 10;
x++;
} if thios assign only once you can write loop 10..99 this way, if it resets as today you cant and
you need to move x out the block (which breaks code locality)

(i say this assuming im not wrong if i made some mistake someone could correct me, as i wouldnt not put someone to wrong state of thinking if im mistaken, but seems probably im ok here)

niedziela, 24 kwietnia 2022 o 00:27:40 UTC+2 bart c napisał(a):
> On Saturday, 23 April 2022 at 01:43:00 UTC+1, fir wrote:
> > may seem funny but i tend to always not remember how declaration of in in loop behaves (though im not c newb for sure)
> >
> > for(int i=0; i<10; i++)
> > {
> > int x = 10;
> > x++;
> > printf("\n %d", x);
> > }
> >
> > for(int i=0; i<10; i++)
> > {
> > static int x = 10;
> > x++;
> > printf("\n %d", x);
> > }
> >
> > those two behaves quite differently (though i test in c++ mode must say but i assume in standard c it is the same)
> >
> > are you able to justify/explain the way it behaves is the right way?
> Inside a function:
>
> int x = 10; // initialised to 10 each time it is encountered (eg. per loop)
>
> static int x = 10; // initialised to 10 at load-time (actually, set in ..data section of exe)
>
> If this was written with my syntax, it would clearer as the first is written using `x := 10`, and the second using `x = 10`. `:=` means a runtime assignment. `=` is taken care at compile-time/load-time.

weird..in context of c i think much better syntax is this x={10} for initialisation
hovever it would make that assigning structures like x = {1,2,3}; would not work in runtime

as i said imo the assign sign in initialisation not quite fits at all so maybe it would be better to
note initialisation as x{10} that would make live such form of whiles

while(int x{10}+=2<100)
it allows mixing initialisation and assignment in place, hovever
while(int x={10}+=2<100) or some varioations of it also allows that

niedziela, 24 kwietnia 2022 o 13:27:42 UTC+2 fir napisał(a):
> >
> in fact when i thinked of it it showed to me that behaviour of
> static int x = 10; may be understood - as realization what initialisation is and what
> static is
> behaviour of int x = 10; in loop hovever comes probably from different point it is practical
> usability (i am not sure though, int x = 10 done to restet to 10 each time is usable but
> im not sure how int x = 10 which not resets is usable)
> in fact if you want in loop make x that is initialised once and then reset it you could put
> int x = 10; if that would only initialize once and x = 10 when you need reset
> in form as it is now if im not wrong you cant do it becouse you cant put initialisation
> in loop that only assign once, so you need to put it before whole loop which is definitivly bad
>
> see
>
> while(x<100)
> {
> int x = 10;
> x++;
> }

well this would also needed that while header has acces to inside block variables but it could be other example

while(1)
{
int x = 10;
x++;
if(x==99) break;
}
and i think such constructions are probably practically usable

> if thios assign only once you can write loop 10..99 this way, if it resets as today you cant and
> you need to move x out the block (which breaks code locality)
>
> (i say this assuming im not wrong if i made some mistake someone could correct me, as i wouldnt not put someone to wrong state of thinking if im mistaken, but seems probably im ok here)

Michael Bäuerle <michael.baeuerle@gmx.net> writes:
[...]
> According to C11 Paragraph 5.1.2, the variable must already be
> initialized when f() is called for the first time (at program startup,
> see above).
>
> Even if I see no explicit statement in C11, that the initializer must
> be constant, using variable x is not possible because the value of x
> may be unknown at program startup.

N1570 6.7.9p4, under "Constraints":

All the expressions in an initializer for an object that has static
or thread storage duration shall be constant expressions or string
literals.

> If I try to compile your code above, the compiler says:
> |
> | error: initializer element is not constant

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

Keith Thompson wrote:
> Michael Bäuerle <michael.baeuerle@gmx.net> writes:
> >
> [...]
> > According to C11 Paragraph 5.1.2, the variable must already be
> > initialized when f() is called for the first time (at program startup,
> > see above).
> >
> > Even if I see no explicit statement in C11, that the initializer must
> > be constant, using variable x is not possible because the value of x
> > may be unknown at program startup.
>
> N1570 6.7.9p4, under "Constraints":
>
> All the expressions in an initializer for an object that has static
> or thread storage duration shall be constant expressions or string
> literals.

Thank you. I have overlooked this paragraph.

On 4/22/22 7:42 PM, fir wrote:
> may seem funny but i tend to always not remember how declaration of in in loop behaves (though im not c newb for sure)
>
> for(int i=0; i<10; i++)
> {
> int x = 10;

In this loop the object designated by 'x' has "auto" storage duration -
its lifetime is limited to a single loop iteration. Logically speaking,
a new instance of 'x' is created and initialized at the beginning of the
loop body and destroyed at the end of the loop body[1].

> x++;
> printf("\n %d", x);
> }
>
> for(int i=0; i<10; i++)
> {
> static int x = 10;

In this loop the object designated by 'x' has "static" storage duration
(thanks to the 'static' keyword) - its lifetime is the same as the
overall program. The object designated by 'x' will be created and
initialized once at program startup and destroyed when the program
terminates.

> x++;
> printf("\n %d", x);
> }
>
> those two behaves quite differently (though i test in c++ mode must say but i assume in standard c it is the same)
>
> are you able to justify/explain the way it behaves is the right way?

Chapter and verse (N1570):

> 6.2.4 Storage durations of objects
>
> ...
>
> 3 An object whose identifier is declared without the storage-class
> specifier _Thread_local, and either with external or internal linkage
> or with the storage-class specifier static, has static storage
> duration. Its lifetime is the entire execution of the program and its
> stored value is initialized only once, prior to program startup.
>
> ...
>
> 5 An object whose identifier is declared with no linkage and without
> the storage-class specifier static has automatic storage duration, as
> do some compound literals. The result of attempting to indirectly
> access an object with automatic storage duration from a thread other
> than the one with which the object is associated is implementation-
> defined.
>
> 6 For such an object that does not have a variable length array type,
> its lifetime extends from entry into the block with which it is
> associated until execution of that block ends in any way. (Entering an
> enclosed block or calling a function suspends, but does not end,
> execution of the current block.) If the block is entered recursively,
> a new instance of the object is created each time. The initial value
> of the object is indeterminate. If an initialization is specified for
> the object, it is performed each time the declaration or
> compound literal is reached in the execution of the block; otherwise,
> the value becomes indeterminate each time the declaration is reached.

So, if you're seeing the first loop print

11
11
11
11
11
...

and the second loop print

11
12
13
14
15
...

then yes, it's behaving as expected.

------------------

[1] In practice a single memory location will be used rather than
allocating and deallocating memory with each iteration, it will just be
re-initialized each time through the loop.