4 ms·

I think the parent is talking about the c pattern of having the last member of a struct be a zero length array, which is actually a dynamically sized array that

I think the parent is talking about the c pattern of having the last member of a struct be a zero length array, which is actually a dynamically sized array that the struct is only the header to (ostensibly with another field of the struct specifying the length of the array). It's fallen a bit out of favor, but it is a handy way to commingle the header and array with one allocation/pointer. And interestingly COBOL handled this in a cleaner way. I forget some of the specfics but there was a way to specify to the compiler that one field of a record specified the length of the following array, allowing the same pattern in a type safe way.

ChrisSD 4y ago
According to the C spec, zero length arrays are explicitly illegal. > Zero-length array declarations are not allowed, even though some compilers offer them as extensions (typically as a pre-C99 implementation of flexible array members). However, as they say, gcc (and therefore clang) have an extension that allows it. So does MSVC but it works slightly differently.
- fsckboy 4y ago
  you should be specific about which C spec you are referring to, you talk about "the C spec" and then you mention the "pre-C99 implementation". Maybe you mean they've always been illegal in every version, but it would be more clear.
  - deleted 4y ago
    [deleted]
  - ChrisSD 4y ago
    The bit after `>` is a quote, not my words. See https://en.cppreference.com/w/c/language/array https://en.cppreference.com/w/c/language/array for the source It's saying that C99 implemented flexible array members but before then some compilers introduced their own (nonstandard) implementation of flexible array members, using the (not allowed) zero sized array notation.
    - segfaultbuserr 4y ago
      The sequence of event was basically: 1. Pre-C99, no flexible array was allowed. 2. Gradually, people started using the "size-1 array at the end of a sturct but write beyond" hack as flexible array. 3. As an attempt to do the hack in a more ordered manner, some compilers, including GCC, started officially supporting the non-standard "size-0" array extension. 4. C99 added flexible array with indefinite length (array[]), while prohibiting both the undefined-behavior "array[1]" and the non-standard extentios "array[0]". So when people say "size-0" array, it could mean either of these three things, and it does get a bit confusing. But fundamentally the idea was the same, all of the three techniques are used to achieve the same practical effect.
  - alerighi 4y ago
    In reality, who cares of what the C spec says? Unless you have to port code on different compilers (which is very unlikely, unless you are building a library meant to be shared with different projects) you only care about the fact that the code works correctly with the compiler you choose to use. I don't get all the programmers that scandalize if you use GNU extensions, they are fine, and mostly useful, so if you are using GCC to program I don't see why not use -std=gnu11 instead of -std=c11... who cares if the program is not compliant? Even if you want to be compliant to share code, the C standard is you last problem, the thing is that you probably use a ton of libraries and header files specific to that implementation (such as POSIX or even worse Linux-specific stuff), so your code is 99% not portable anyway without rewriting most of it.
    - andreareina 4y ago
      It’s all well and good until someone else wants to compile it on clang[1]. There’s a lot of value in C being a lingua franca of sorts, and that depends on a cross-implementation understanding of semantics, i.e. standards, (though that doesn’t have to be from whatever official body that produced C99 etc). [1] IIRC on OSX[2] gcc actually invokes clang [2] stopped upgrading before it became macOS
      - astrange 4y ago
        Clang implements nearly all GCC extensions. (No nested functions.)
ufo 4y ago
According to the article, it's better to use the new flexible array syntax (int arr[]) instead of the old zero-length syntax (int arr[0]), because that allows the compiler emit better warning messages.
- fsckboy 4y ago
  how would compiler confusion manifest between [] and [0] if it wanted to emit warning messages?
  - ufo 4y ago
    Technically, [0] is not allowed by the standard. The real issue is [] vs [1].
ddtaylor 4y ago
> And interestingly COBOL handled this in a cleaner way That is the least reassuring sentence I have read on HN in a while!
- ykonstant 4y ago
  ROFL I can use that. - Boss! - ..yes?! - I was reading a COBOL code base and got a brilliant idea-- - Say no more, you need a vacation. I am sorry, I have been too pushy. Take 3 weeks; just promise me one thing: no COBOL.
le-mark 4y ago
In cobol it wasn’t dynamic, or infinite. The syntax of the array/table declaration includes a maximum and it would allocate the entire array statically up to the max.

ChrisSD 4y ago

According to the C spec, zero length arrays are explicitly illegal. > Zero-length array declarations are not allowed, even though some compilers offer them as extensions (typically as a pre-C99 implementation of flexible array members). However, as they say, gcc (and therefore clang) have an extension that allows it. So does MSVC but it works slightly differently.

fsckboy 4y ago
you should be specific about which C spec you are referring to, you talk about "the C spec" and then you mention the "pre-C99 implementation". Maybe you mean they've always been illegal in every version, but it would be more clear.
- deleted 4y ago
  [deleted]
- ChrisSD 4y ago
  The bit after `>` is a quote, not my words. See https://en.cppreference.com/w/c/language/array https://en.cppreference.com/w/c/language/array for the source It's saying that C99 implemented flexible array members but before then some compilers introduced their own (nonstandard) implementation of flexible array members, using the (not allowed) zero sized array notation.
  - segfaultbuserr 4y ago
    The sequence of event was basically: 1. Pre-C99, no flexible array was allowed. 2. Gradually, people started using the "size-1 array at the end of a sturct but write beyond" hack as flexible array. 3. As an attempt to do the hack in a more ordered manner, some compilers, including GCC, started officially supporting the non-standard "size-0" array extension. 4. C99 added flexible array with indefinite length (array[]), while prohibiting both the undefined-behavior "array[1]" and the non-standard extentios "array[0]". So when people say "size-0" array, it could mean either of these three things, and it does get a bit confusing. But fundamentally the idea was the same, all of the three techniques are used to achieve the same practical effect.
- alerighi 4y ago
  In reality, who cares of what the C spec says? Unless you have to port code on different compilers (which is very unlikely, unless you are building a library meant to be shared with different projects) you only care about the fact that the code works correctly with the compiler you choose to use. I don't get all the programmers that scandalize if you use GNU extensions, they are fine, and mostly useful, so if you are using GCC to program I don't see why not use -std=gnu11 instead of -std=c11... who cares if the program is not compliant? Even if you want to be compliant to share code, the C standard is you last problem, the thing is that you probably use a ton of libraries and header files specific to that implementation (such as POSIX or even worse Linux-specific stuff), so your code is 99% not portable anyway without rewriting most of it.
  - andreareina 4y ago
    It’s all well and good until someone else wants to compile it on clang[1]. There’s a lot of value in C being a lingua franca of sorts, and that depends on a cross-implementation understanding of semantics, i.e. standards, (though that doesn’t have to be from whatever official body that produced C99 etc). [1] IIRC on OSX[2] gcc actually invokes clang [2] stopped upgrading before it became macOS
    - astrange 4y ago
      Clang implements nearly all GCC extensions. (No nested functions.)

ufo 4y ago

According to the article, it's better to use the new flexible array syntax (int arr[]) instead of the old zero-length syntax (int arr[0]), because that allows the compiler emit better warning messages.

fsckboy 4y ago
how would compiler confusion manifest between [] and [0] if it wanted to emit warning messages?
- ufo 4y ago
  Technically, [0] is not allowed by the standard. The real issue is [] vs [1].

ddtaylor 4y ago

> And interestingly COBOL handled this in a cleaner way That is the least reassuring sentence I have read on HN in a while!

ykonstant 4y ago
ROFL I can use that. - Boss! - ..yes?! - I was reading a COBOL code base and got a brilliant idea-- - Say no more, you need a vacation. I am sorry, I have been too pushy. Take 3 weeks; just promise me one thing: no COBOL.

le-mark 4y ago

In cobol it wasn’t dynamic, or infinite. The syntax of the array/table declaration includes a maximum and it would allocate the entire array statically up to the max.