2:03 a.m.
Hi everyone,
I would like to ask you what you think about the initialization of
iterative variables in forloops. I know that present code style does not
allow it. But how I recognized, we use C99, and this feature is here now.
(example)
Instead of:|
|||# inti;
# for(i =0;...)|||
we could write:
||# for(inti =0;...)|
I see an advantage in limiting the validity of such variables. That
means higher code readability. Disadvantages I searched but did not find.
Regards
Petr
2:18 a.m.
On (28/08/15 09:03), Petr Cech wrote:
Hi everyone,
I would like to ask you what you think about the initialization of iterative
variables in forloops. I know that present code style does not allow it. But
how I recognized, we use C99, and this feature is here now.
(example)
Instead of:|
|||# inti;
# for(i =0;...)|||
we could write:
||# for(inti =0;...)|
^
There is a synteax error;
variable inti is not definded :-)
s/inti/int i/
otherwise +1
and there are also precedents in sssd code.
src/lib/sifp/sss_sifp_parser.c:434: for (unsigned int i = 0;
src/providers/ipa/ipa_init.c:103: for (int i = 0; list[i]; i++) {
src/tests/ipa_ldap_opt-tests.c:267: for (int i=0; i < SDAP_OPTS_BASIC; i++) {
src/tools/tools_mc_util.c:173: for (size_t i = 0; i < steps_count; ++i) {
src/util/domain_info_utils.c:74: for (int i=0; parent->sd_enumerate[i]; i++) {
LS
2:40 a.m.
On 08/28/2015 09:18 AM, Lukas Slebodnik wrote:
On (28/08/15 09:03), Petr Cech wrote:
> Hi everyone,
>
> I would like to ask you what you think about the initialization of iterative
> variables in forloops. I know that present code style does not allow it. But
> how I recognized, we use C99, and this feature is here now.
>
> (example)
> Instead of:|
> |||# inti;
> # for(i =0;...)|||
> we could write:
> ||# for(inti =0;...)|
^
There is a synteax error;
variable inti is not definded :-)
s/inti/int i/
Sorry for typo. My mail client plays game with me.
otherwise +1
and there are also precedents in sssd code.
src/lib/sifp/sss_sifp_parser.c:434: for (unsigned int i = 0;
src/providers/ipa/ipa_init.c:103: for (int i = 0; list[i]; i++) {
src/tests/ipa_ldap_opt-tests.c:267: for (int i=0; i < SDAP_OPTS_BASIC; i++) {
src/tools/tools_mc_util.c:173: for (size_t i = 0; i < steps_count; ++i) {
src/util/domain_info_utils.c:74: for (int i=0; parent->sd_enumerate[i]; i++) {
LS
_______________________________________________
sssd-devel mailing list
sssd-devel(a)lists.fedorahosted.org
https://lists.fedorahosted.org/mailman/listinfo/sssd-devel
6:33 a.m.
On Fri, 28 Aug 2015, Petr Cech wrote:
Hi everyone,
I would like to ask you what you think about the initialization of
iterative variables in forloops. I know that present code style does
not allow it. But how I recognized, we use C99, and this feature is
here now.
(example)
Instead of:|
|||# inti;
# for(i =0;...)|||
we could write:
||# for(inti =0;...)|
I see an advantage in limiting the validity of such variables. That
means higher code readability. Disadvantages I searched but did not
find.
What this misses is a use case of indexed searches where resulting index
value is used beyond the loop itself. By changing context of variable
declaration, you make variable inaccessible outside of the loop.
According to C standard, declaration expression in for() should only be
used to declare identifiers for objects having storage class auto or
register and "the scope of any identifiers it declares is the remainder
of the declaration and the entire loop, including the other two
expressions" (6.8.5.3 of C11 standard, C99 had similar sentence).
--
/ Alexander Bokovoy
2:31 p.m.
On Fri, 2015-08-28 at 09:03 +0200, Petr Cech wrote:
Hi everyone,
I would like to ask you what you think about the initialization of
iterative variables in forloops. I know that present code style does not
allow it. But how I recognized, we use C99, and this feature is here now.
(example)
Instead of:|
|||# inti;
# for(i =0;...)|||
we could write:
||# for(inti =0;...)|
I see an advantage in limiting the validity of such variables. That
means higher code readability. Disadvantages I searched but did not find.
I think it is ok to accept this style when there is *only one* variable
involved and the iterator variable is useful exclusively within the for
loop. I used this style elsewhere and it was ok.
Much care need to be taken when *converting* code to this style, because
in many case the index is used after the for loop to check for
failure/success when the loop breaks in the middle.
Simo.
P.S: please do not use HTML emails, see how butchered your email comes
out in the txt version.
--
Simo Sorce * Red Hat, Inc * New York
3:43 a.m.
On (30/08/15 15:31), Simo Sorce wrote:
On Fri, 2015-08-28 at 09:03 +0200, Petr Cech wrote:
> Hi everyone,
>
> I would like to ask you what you think about the initialization of
> iterative variables in forloops. I know that present code style does not
> allow it. But how I recognized, we use C99, and this feature is here now.
>
> (example)
> Instead of:|
> |||# inti;
> # for(i =0;...)|||
> we could write:
> ||# for(inti =0;...)|
>
> I see an advantage in limiting the validity of such variables. That
> means higher code readability. Disadvantages I searched but did not find.
I think it is ok to accept this style when there is *only one* variable
involved and the iterator variable is useful exclusively within the for
loop. I used this style elsewhere and it was ok.
Much care need to be taken when *converting* code to this style, because
in many case the index is used after the for loop to check for
failure/success when the loop breaks in the middle.
We should avoid mass converting to this style. The new approch
should be only used as part of rewriting function or in new functions.
BTW Should it be recommended or just allowed to use?
LS
3:52 a.m.
On (29/08/15 14:33), Alexander Bokovoy wrote:
On Fri, 28 Aug 2015, Petr Cech wrote:
>Hi everyone,
>
>I would like to ask you what you think about the initialization of
>iterative variables in forloops. I know that present code style does not
>allow it. But how I recognized, we use C99, and this feature is here now.
>
>(example)
>Instead of:|
>|||# inti;
># for(i =0;...)|||
>we could write:
>||# for(inti =0;...)|
>
>I see an advantage in limiting the validity of such variables. That means
>higher code readability. Disadvantages I searched but did not find.
What this misses is a use case of indexed searches where resulting index
value is used beyond the loop itself. By changing context of variable
declaration, you make variable inaccessible outside of the loop.
I would say it's exactly the purpose of this proposal.
To decrease scope of visibility so the index variable with short name
cannot be misused for different purpose.
LS
6:09 a.m.
On Mon, 31 Aug 2015, Lukas Slebodnik wrote:
On (29/08/15 14:33), Alexander Bokovoy wrote:
>On Fri, 28 Aug 2015, Petr Cech wrote:
>>Hi everyone,
>>
>>I would like to ask you what you think about the initialization of
>>iterative variables in forloops. I know that present code style does not
>>allow it. But how I recognized, we use C99, and this feature is here now.
>>
>>(example)
>>Instead of:|
>>|||# inti;
>># for(i =0;...)|||
>>we could write:
>>||# for(inti =0;...)|
>>
>>I see an advantage in limiting the validity of such variables. That means
>>higher code readability. Disadvantages I searched but did not find.
>What this misses is a use case of indexed searches where resulting index
>value is used beyond the loop itself. By changing context of variable
>declaration, you make variable inaccessible outside of the loop.
>
I would say it's exactly the purpose of this proposal.
To decrease scope of visibility so the index variable with short name
cannot be misused for different purpose.
Huh? There are valid cases where you search
for an element and then use
it further in the code. The index is what you get as the result of the
search, not a reference to the element. Sometimes you need an element's
reference but in many cases you need an index.
Reducing scope is fine if you understand the context but claiming
'misuse' is a bit too much here.
I'd suggest adding this syntax recommendation to SSSD C coding style
guidelines but add as well a bit of explanation on these two types of
loop usage patterns.
--
/ Alexander Bokovoy
6:20 a.m.
On Mon, Aug 31, 2015 at 02:09:19PM +0300, Alexander Bokovoy wrote:
On Mon, 31 Aug 2015, Lukas Slebodnik wrote:
>On (29/08/15 14:33), Alexander Bokovoy wrote:
>>On Fri, 28 Aug 2015, Petr Cech wrote:
>>>Hi everyone,
>>>
>>>I would like to ask you what you think about the initialization of
>>>iterative variables in forloops. I know that present code style does not
>>>allow it. But how I recognized, we use C99, and this feature is here now.
>>>
>>>(example)
>>>Instead of:|
>>>|||# inti;
>>># for(i =0;...)|||
>>>we could write:
>>>||# for(inti =0;...)|
>>>
>>>I see an advantage in limiting the validity of such variables. That means
>>>higher code readability. Disadvantages I searched but did not find.
>>What this misses is a use case of indexed searches where resulting index
>>value is used beyond the loop itself. By changing context of variable
>>declaration, you make variable inaccessible outside of the loop.
>>
>I would say it's exactly the purpose of this proposal.
>To decrease scope of visibility so the index variable with short name
>cannot be misused for different purpose.
Huh? There are valid cases where you search for an element and then use
it further in the code. The index is what you get as the result of the
search, not a reference to the element. Sometimes you need an element's
reference but in many cases you need an index.
Reducing scope is fine if you understand the context but claiming
'misuse' is a bit too much here.
I'd suggest adding this syntax recommendation to SSSD C coding style
guidelines but add as well a bit of explanation on these two types of
loop usage patterns.
Then I would suggest not to use the generic "i" name, but a more
descriptive one for the variable.
On a related note -- Michal, any progress on updating the code
guidelines?
6:22 a.m.
On 08/31/2015 01:09 PM, Alexander Bokovoy wrote:
On Mon, 31 Aug 2015, Lukas Slebodnik wrote:
> On (29/08/15 14:33), Alexander Bokovoy wrote:
>> On Fri, 28 Aug 2015, Petr Cech wrote:
>>> Hi everyone,
>>>
>>> I would like to ask you what you think about the initialization of
>>> iterative variables in forloops. I know that present code style does
>>> not
>>> allow it. But how I recognized, we use C99, and this feature is here
>>> now.
>>>
>>> (example)
>>> Instead of:|
>>> |||# inti;
>>> # for(i =0;...)|||
>>> we could write:
>>> ||# for(inti =0;...)|
>>>
>>> I see an advantage in limiting the validity of such variables. That
>>> means
>>> higher code readability. Disadvantages I searched but did not find.
>> What this misses is a use case of indexed searches where resulting index
>> value is used beyond the loop itself. By changing context of variable
>> declaration, you make variable inaccessible outside of the loop.
>>
> I would say it's exactly the purpose of this proposal.
> To decrease scope of visibility so the index variable with short name
> cannot be misused for different purpose.
Huh? There are valid cases where you search for an element and then use
it further in the code. The index is what you get as the result of the
search, not a reference to the element. Sometimes you need an element's
reference but in many cases you need an index.
Yes, I agree. There are different situations.
Reducing scope is fine if you understand the context but claiming
'misuse' is a bit too much here.
+1
I'd suggest adding this syntax recommendation to SSSD C coding
style
guidelines but add as well a bit of explanation on these two types of
loop usage patterns.
+1
Petr
6:24 a.m.
On 08/31/2015 01:20 PM, Jakub Hrozek wrote:
On Mon, Aug 31, 2015 at 02:09:19PM +0300, Alexander Bokovoy wrote:
> On Mon, 31 Aug 2015, Lukas Slebodnik wrote:
>> On (29/08/15 14:33), Alexander Bokovoy wrote:
>>> On Fri, 28 Aug 2015, Petr Cech wrote:
>>>> Hi everyone,
>>>>
>>>> I would like to ask you what you think about the initialization of
>>>> iterative variables in forloops. I know that present code style does not
>>>> allow it. But how I recognized, we use C99, and this feature is here
now.
>>>>
>>>> (example)
>>>> Instead of:|
>>>> |||# inti;
>>>> # for(i =0;...)|||
>>>> we could write:
>>>> ||# for(inti =0;...)|
>>>>
>>>> I see an advantage in limiting the validity of such variables. That
means
>>>> higher code readability. Disadvantages I searched but did not find.
>>> What this misses is a use case of indexed searches where resulting index
>>> value is used beyond the loop itself. By changing context of variable
>>> declaration, you make variable inaccessible outside of the loop.
>>>
>> I would say it's exactly the purpose of this proposal.
>> To decrease scope of visibility so the index variable with short name
>> cannot be misused for different purpose.
> Huh? There are valid cases where you search for an element and then use
> it further in the code. The index is what you get as the result of the
> search, not a reference to the element. Sometimes you need an element's
> reference but in many cases you need an index.
>
> Reducing scope is fine if you understand the context but claiming
> 'misuse' is a bit too much here.
>
> I'd suggest adding this syntax recommendation to SSSD C coding style
> guidelines but add as well a bit of explanation on these two types of
> loop usage patterns.
Then I would suggest not to use the generic "i" name, but a more
descriptive one for the variable.
On a related note -- Michal, any progress on updating the code
guidelines?
Yes, but I would prefer to update the coding guidelines after
Petr finish the wiki refactoring, so that I will not be adding
stuff under his nose.
Michal
3:58 a.m.
On Mon, Aug 31, 2015 at 01:24:17PM +0200, Michal Židek wrote:
On 08/31/2015 01:20 PM, Jakub Hrozek wrote:
>On Mon, Aug 31, 2015 at 02:09:19PM +0300, Alexander Bokovoy wrote:
>>On Mon, 31 Aug 2015, Lukas Slebodnik wrote:
>>>On (29/08/15 14:33), Alexander Bokovoy wrote:
>>>>On Fri, 28 Aug 2015, Petr Cech wrote:
>>>>>Hi everyone,
>>>>>
>>>>>I would like to ask you what you think about the initialization of
>>>>>iterative variables in forloops. I know that present code style does
not
>>>>>allow it. But how I recognized, we use C99, and this feature is here
now.
>>>>>
>>>>>(example)
>>>>>Instead of:|
>>>>>|||# inti;
>>>>># for(i =0;...)|||
>>>>>we could write:
>>>>>||# for(inti =0;...)|
>>>>>
>>>>>I see an advantage in limiting the validity of such variables. That
means
>>>>>higher code readability. Disadvantages I searched but did not find.
>>>>What this misses is a use case of indexed searches where resulting index
>>>>value is used beyond the loop itself. By changing context of variable
>>>>declaration, you make variable inaccessible outside of the loop.
>>>>
>>>I would say it's exactly the purpose of this proposal.
>>>To decrease scope of visibility so the index variable with short name
>>>cannot be misused for different purpose.
>>Huh? There are valid cases where you search for an element and then use
>>it further in the code. The index is what you get as the result of the
>>search, not a reference to the element. Sometimes you need an element's
>>reference but in many cases you need an index.
>>
>>Reducing scope is fine if you understand the context but claiming
>>'misuse' is a bit too much here.
>>
>>I'd suggest adding this syntax recommendation to SSSD C coding style
>>guidelines but add as well a bit of explanation on these two types of
>>loop usage patterns.
>
>Then I would suggest not to use the generic "i" name, but a more
>descriptive one for the variable.
>
>On a related note -- Michal, any progress on updating the code
>guidelines?
Yes, but I would prefer to update the coding guidelines after
Petr finish the wiki refactoring, so that I will not be adding
stuff under his nose.
Michal
If you have time, can you help with reviewing Petr's wiki changes, then?
5:04 a.m.
On 09/01/2015 10:58 AM, Jakub Hrozek wrote:
On Mon, Aug 31, 2015 at 01:24:17PM +0200, Michal Židek wrote:
> On 08/31/2015 01:20 PM, Jakub Hrozek wrote:
>> On Mon, Aug 31, 2015 at 02:09:19PM +0300, Alexander Bokovoy wrote:
>>> On Mon, 31 Aug 2015, Lukas Slebodnik wrote:
>>>> On (29/08/15 14:33), Alexander Bokovoy wrote:
>>>>> On Fri, 28 Aug 2015, Petr Cech wrote:
>>>>>> Hi everyone,
>>>>>>
>>>>>> I would like to ask you what you think about the initialization
of
>>>>>> iterative variables in forloops. I know that present code style
does not
>>>>>> allow it. But how I recognized, we use C99, and this feature is
here now.
>>>>>>
>>>>>> (example)
>>>>>> Instead of:|
>>>>>> |||# inti;
>>>>>> # for(i =0;...)|||
>>>>>> we could write:
>>>>>> ||# for(inti =0;...)|
>>>>>>
>>>>>> I see an advantage in limiting the validity of such variables.
That means
>>>>>> higher code readability. Disadvantages I searched but did not
find.
>>>>> What this misses is a use case of indexed searches where resulting
index
>>>>> value is used beyond the loop itself. By changing context of
variable
>>>>> declaration, you make variable inaccessible outside of the loop.
>>>>>
>>>> I would say it's exactly the purpose of this proposal.
>>>> To decrease scope of visibility so the index variable with short name
>>>> cannot be misused for different purpose.
>>> Huh? There are valid cases where you search for an element and then use
>>> it further in the code. The index is what you get as the result of the
>>> search, not a reference to the element. Sometimes you need an element's
>>> reference but in many cases you need an index.
>>>
>>> Reducing scope is fine if you understand the context but claiming
>>> 'misuse' is a bit too much here.
>>>
>>> I'd suggest adding this syntax recommendation to SSSD C coding style
>>> guidelines but add as well a bit of explanation on these two types of
>>> loop usage patterns.
>>
>> Then I would suggest not to use the generic "i" name, but a more
>> descriptive one for the variable.
>>
>> On a related note -- Michal, any progress on updating the code
>> guidelines?
>
> Yes, but I would prefer to update the coding guidelines after
> Petr finish the wiki refactoring, so that I will not be adding
> stuff under his nose.
>
> Michal
If you have time, can you help with reviewing Petr's wiki changes, then?
Ok, will do.
Michal
3164
days inactive
3168
days old
sssd-devel@lists.fedorahosted.org
12 comments
6 participants
participants (6)
-
Alexander Bokovoy -
Jakub Hrozek -
Lukas Slebodnik -
Michal Židek -
Petr Cech -
Simo Sorce