Re: Loops (was Re: do { quit; } else { })

On 5/11/25 06:02, David Brown wrote:

On 11/05/2025 10:21, Muttley@dastardlyhq.com wrote:

On Sat, 10 May 2025 14:29:50 -0700
Tim Rentsch <tr.17687@z991.linuxsc.com> gabbled:

...

The use I'm talking about here may be illustrated as follows:
>
   double
   average( double values[ static 10 ] ){
      double total = 0;
      for(  int i = 0;  i < 10;  i++  ){
         total += values[i];
      }
      return  total / 10;
   }
>
What word would you suggest to be used in place of 'static'
there?

>
If I knew what the hell it was supposed to do I'd tell you.
>

 
Using "static" inside array parameters is, IME, extremely rare.  It was
added in C99, and tells the compiler that whenever "average" is called,
the "values" parameter points to an array of at least 10 doubles.  It

More precisely, it makes it undefined behavior for values to point to an
array of less than 10 doubles.

does not affect the signature of the function or compatibility with any
other declarations, and is AFAIK rarely checked by compilers.

I'd have preferred it if violating that requirement was a constraint
violation, but it can't be, because there are many cases where a
compiler cannot be sure how long the array is that a pointer points at.
However, the fact that the behavior is undefined justifies a compiler
reacting to the case when it can be sure that the requirement will be
violated. That's the main reason I like this feature, and dislike
compilers that fail to take advantage of that opportunity. I never
considered it to be about efficiency, though there are cases where it
can result in more efficient code.

In an example like the one above, it is completely useless for
compilation - it tells the compiler nothing that it does not already
know.  An optimising compiler will see that you are accessing values[0]
to values[9], and if it can get better results through vectorising,
prefetching, etc., then it will do so.  (You can argue that the "static
10" is still useful as an indicator to human readers, but I am not
convinced of that.)

It's main potential usefulness is not in the definition of the function,
but in calls to the function. If the calls occur in a different
translation unit from the definition, the compiler does not have the
needed information.