Re: Two questions on arrays with size defined by variables

Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:

On 09.02.2025 09:06, Andrey Tarasevich wrote:

On Sat 2/8/2025 11:50 PM, Janis Papanagnou wrote:

I've found examples on the Net where the arrays have been defined in a
function context and the size passed as parameter
>
   f(int n) {
      char * arr[n];
      ...
   }

 
Yes, that would be a VLA.
 

That reminded me on other languages where you'd need at least a block
context for dynamically sized arrays, like
>
   int n = 5;
   {
      char * arr[n];
      ...
   }

 
But a function body is in itself a block. Inside a function body you are
already in "a block context".
 

Anyway. I tried it without function or block context
>
   int n = 5;
   char * arr[n];
   ...
>
and it seemed to work seamlessly like that (with GNU cc, -std=C99).

 
You mean you did this at file scope? No, VLAs are illegal at file scope.
And I was unable to repeat this feat in GCC.

>
Oh, sorry, no; above I had just written an excerpt. - Actually I had
those two examples above within a main() function. - Sorry again for
my inaccuracy.
>
What I meant was (with surrounding context) that I knew (from _other_
languages) a syntax like
>
main ()
{
  int n = 5;
>
  {
     char * arr[n];
     ...
  }
}
>
And in "C" (C99) I tried it *without* the _inner block_
>
main ()
{
  int n = 5;
  char * arr[n];
  ...
}

The first line needs to be `int main(void)`.  The "implicit int"
misfeature was removed in C99.  Your compiler might let you get away
with it; many C compilers are quite lax by default.  For gcc, use
"-std=cNN -pedantic" to enforce the language rules, where NN specifies
the language version.

and it seemed to work that way. (In those other languages that wasn't
possible.)

VLAs were introduced in C99, so the above is invalid in C90 with or
without the inner block.  In C99 and later, there's no requirement to
put the VLA object definition in an inner block (if the implementation
supports them).  (C99 did add the ability to mix declarations and
statements, but that's not relevant to your example).

Q1: Is this a correct (portable) form?

 
VLA objects have to be declared locally. However, keep in mind that
support for local declarations of VLA _objects_ is now optional (i.e.
not portable). Support for variably-modified _types_ themselves (VLA
types) is mandatory. But you are not guaranteed to be able to declare an
actual VLA variable.

>
I fear I don't understand what you're saying here. - By "now" do you
mean newer versions of the C standards? That you can rely only, say,
rely on it with C99 but maybe not before and not in later C standards
conforming compilers?

C90 didn't have VLAs at all.

C99 introduced them and required all implementations to support them.

C11 made variably modified types optional.

C23 still makes variable length arrays with automatic storage duration
optional but "Parameters declared with variable length array types are
adjusted and then define objects of automatic storage duration with
pointer types. Thus, support for such declarations is mandatory."
(Support for C23 is still preliminary.)

For my purpose it would be okay to know whether with the C99 version
(that I used) it's okay, or whether that's some GNU specific extension
or some such.

C99 requires support for local objects of variable length array types.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */