164

Just curious, what actually happens if I define a zero-length array int array[0]; in code? GCC doesn't complain at all.

Sample Program

#include <stdio.h> int main() { int arr[0]; return 0; }

Clarification

I'm actually trying to figure out if zero-length arrays initialised this way, instead of being pointed at like the variable length in Darhazer's comments, are optimised out or not.

This is because I have to release some code out into the wild, so I'm trying to figure out if I have to handle cases where the SIZE is defined as 0, which happens in some code with a statically defined int array[SIZE];

I was actually surprised that GCC does not complain, which led to my question. From the answers I've received, I believe the lack of a warning is largely due to supporting old code which has not been updated with the new [] syntax.

Because I was mainly wondering about the error, I am tagging Lundin's answer as correct (Nawaz's was first, but it wasn't as complete) -- the others were pointing out its actual use for tail-padded structures, while relevant, isn't exactly what I was looking for.

Improve this question
14
  • 58
    @AlexanderCorwin: Unfortunately in C++, with undefined behavior, non-standard extensions, and other anomalies, trying something out yourself is often not a path to knowledge. Commented Mar 15, 2012 at 15:19
  • 7
    @JustinKirk I just got trapped by that too by testing and seing it worked. And due to the criticism I received in my post, I learnt that testing and seing it working does not mean it is valid and legal. So a self test is not valid sometimes. Commented Mar 15, 2012 at 15:39
  • 4
    @JustinKirk, see Matthieu's answer for an example of where you would use it. It also might come in handy in a template where the array size is a template parameter. The example in the question is obviously out of context. Commented Mar 15, 2012 at 15:49
  • 3
    @JustinKirk: What's the purpose of [] in Python or even "" in C? Sometimes, you've got a function or a macro that requires an array, but you don't have any data to put in it. Commented Mar 15, 2012 at 16:42
  • 21
    What is "C/C++"? These are two separate languages Commented Mar 15, 2012 at 21:32

8 Answers 8

Reset to default
119

An array cannot have zero size.

ISO 9899:2011 6.7.6.2:

If the expression is a constant expression, it shall have a value greater than zero.

The above text is true both for a plain array (paragraph 1). For a VLA (variable length array), the behavior is undefined if the expression's value is less than or equal to zero (paragraph 5). This is normative text in the C standard. A compiler is not allowed to implement it differently.

gcc -std=c99 -pedantic gives a warning for the non-VLA case.

Improve this answer
Sign up to request clarification or add additional context in comments.

21 Comments

"it must actually give an error" - the distinction between "warnings" and "errors" isn't recognized in the standard (it only mentions "diagnostics"), and the only situation where compilation must stop [i.e. the real-world difference between warning and error] is on encountering an #error directive.
FYI, as a general rule, the (C or C++) standards only state what compilers must allow, but not what they must disallow. In some cases, they will state that the compiler should issue a "diagnostic" but that's about as specific as they get. The rest is left to the compiler vendor. EDIT: What Random832 said too.
@Lundin "A compiler isn't allowed to build a binary containing zero-length arrays." The standard says absolutely nothing of the sort. It only says that it must generate at least one diagnostic message when given source code containing an array with a zero-length constant expression for its size. The only circumstance under which the standard forbids a compiler to build a binary is if it encounters an #error preprocessor directive.
@Lundin Generating a binary for all correct cases satisfies #1, and generating or not generating one for incorrect cases would not affect it. Printing a warning is sufficient for #3. This behavior has no relevance to #2, since the standard does not define the behavior of this source code.
@Lundin: The point is that your statement is mistaken; conforming compilers are allowed to build a binary containing a zero-length arrays, as long as a diagnostic is issued.
|
117

As per the standard, it is not allowed.

However it's been current practice in C compilers to treat those declarations as a flexible array member (FAM) declaration:

C99 6.7.2.1, §16: As a special case, the last element of a structure with more than one named member may have an incomplete array type; this is called a flexible array member.

The standard syntax of a FAM is:

struct Array { size_t size; int content[]; };

The idea is that you would then allocate it so:

void foo(size_t x) { Array* array = malloc(sizeof(size_t) + x * sizeof(int)); array->size = x; for (size_t i = 0; i != x; ++i) { array->content[i] = 0; } }

You might also use it statically (gcc extension):

Array a = { 3, { 1, 2, 3 } };

This is also known as tail-padded structures (this term predates the publication of the C99 Standard) or struct hack (thanks to Joe Wreschnig for pointing it out).

However this syntax was standardized (and the effects guaranteed) only lately in C99. Before a constant size was necessary.

  • 1 was the portable way to go, though it was rather strange.
  • 0 was better at indicating intent, but not legal as far as the Standard was concerned and supported as an extension by some compilers (including gcc).

The tail padding practice, however, relies on the fact that storage is available (careful malloc) so is not suited to stack usage in general.

Improve this answer

17 Comments

@Lundin: I have not seen any VLA here, all the sizes are known at compile time. The flexible array term comes from gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Zero-Length.html and doe qualify int content[]; here as far as I understand. Since I am not too savvy on C terms of the art... could you confirm whether my reasoning seems correct ?
@MatthieuM.: C99 6.7.2.1, §16: As a special case, the last element of a structure with more than one named member may have an incomplete array type; this is called a flexible array member.
This idiom is also known by the name "struct hack", and I've met more people familiar with that name than "tail-padded structure" (never heard it before except maybe as a generic reference to padding a struct for future ABI compatibility) or "flexible array member" which I first heard in C99.
Using an array size of 1 for the struct hack would avoid having compilers squawk, but was only "portable" because compiler writers were nice enough to acknowledge such usage as a de-facto standard. Were it not for the prohibition on zero-sized arrays, programmer' consequent usage of single-element arrays as a crummy substitute, and compiler writers' historical attitude that they should serve programmer's needs even when not required to by the Standard, compiler writers could have easily and usefully optimized foo[x] to foo[0] whenever foo was a single-element array.
@RobertSsupportsMonicaCellio: It as shown explicitly in the answer, but at the end. I've front-loaded the explanation as well, to make it clearer from the get go.
|
64

In Standard C and C++, zero-size array is not allowed..

If you're using GCC, compile it with -pedantic option. It will give warning, saying:

zero.c:3:6: warning: ISO C forbids zero-size array 'a' [-pedantic]

In case of C++, it gives similar warning.

Improve this answer

7 Comments

In Visual C++ 2010: error C2466: cannot allocate an array of constant size 0
-Werror simply turns all warnings into errors, that doesn't fix the incorrect behavior of the GCC compiler.
C++ Builder 2009 also correctly gives an error: [BCC32 Error] test.c(3): E2021 Array must have at least one element
Instead of -pedantic -Werror, you could also just do -pedantic-errors
A zero-sized array is not quite the same thing as a zero-sized std::array. (Aside: I recall but can't find the source that VLAs were considered and explicitly rejected from being in C++.)
|
30

It's totally illegal, and always has been, but a lot of compilers neglect to signal the error. I'm not sure why you want to do this. The one use I know of is to trigger a compile time error from a boolean:

char someCondition[ condition ];

If condition is a false, then I get a compile time error. Because compilers do allow this, however, I've taken to using: 

char someCondition[ 2 * condition - 1 ];

This gives a size of either 1 or -1, and I've never found a compiler which would accept a size of -1.

Improve this answer

4 Comments

This is an interesting hack to use it for.
It's a common trick in metaprogramming, I think. I wouldn't be surprised if the implementations of STATIC_ASSERT used it.
Why not just: #if condition \n #error whatever \n #endif
@Jerfov2 because the condition may not be known at preprocessing time, only compile time
15

Another use of zero-length arrays is for making variable-length object (pre-C99). Zero-length arrays are different from flexible arrays which have [] without 0.

Quoted from gcc doc:

Zero-length arrays are allowed in GNU C. They are very useful as the last element of a structure that is really a header for a variable-length object:

 struct line { int length; char contents[0]; }; struct line *thisline = (struct line *) malloc (sizeof (struct line) + this_length); thisline->length = this_length;

In ISO C99, you would use a flexible array member, which is slightly different in syntax and semantics:

  • Flexible array members are written as contents[] without the 0.
  • Flexible array members have incomplete type, and so the sizeof operator may not be applied.

A real-world example is zero-length arrays of struct kdbus_item in kdbus.h (a Linux kernel module).

Improve this answer

5 Comments

IMHO, there was no good reason for the Standard to have forbidden zero-length arrays; it could have zero-sized objects just fine as members of a structure and regarded them as void* for purposes of arithmetic (so adding or subtracting pointers to zero-size objects would be forbidden). While Flexible Array Members are mostly better than zero-sized arrays, the they can also act as a sort of "union" to alias things without adding an extra level of "syntactic" indirection to what follows (e.g. given struct foo {unsigned char as_bytes[0]; int x,y; float z;} one can access members x..z...
...directly without having to say e.g. myStruct.asFoo.x, etc. Further, IIRC, C squawks at any effort to include a flexible array member within a struct, thus making it impossible have a structure which includes multiple other flexible-array members of known-length content.
@supercat a good reason is to maintain the integrity of the rule about accessing outside array bounds. As the last member of a struct, the C99 flexible array member achieves exactly the same effect as GCC zero-sized array, but without needing to add special cases to other rules. IMHO it's an improvement that sizeof x->contents is an error in ISO C as opposed to returning 0 in gcc. Zero-sized arrays that are not struct members introduce a bunch of other problems.
@M.M: What problems would they cause if subtracting two equal pointers to a zero-sized object were defined as yielding zero (as would subtracting equal pointers to any size of object), and subtracting unequal pointers to zero-sized objects was defined as yielding Unspecified Value? If the Standard had specified that an implementation may allow a struct containing an FAM to be embedded within another struct provided that the next element in the latter struct is either an array with the same element type as the FAM or a struct starting with such an array, and provided that...
...it recognizes the FAM as aliasing the array (if alignment rules would cause the arrays to land at different offsets, a diagnostic would be required), that would have been very useful. As it is, there's no good way to have a method which accept pointers to structures of the general format struct {int n; THING dat[];} and can work with things of static or automatic duration.
9

I'll add that there is a whole page of the online documentation of gcc on this argument.

Some quotes:

Zero-length arrays are allowed in GNU C.

In ISO C90, you would have to give contents a length of 1

and

GCC versions before 3.0 allowed zero-length arrays to be statically initialized, as if they were flexible arrays. In addition to those cases that were useful, it also allowed initializations in situations that would corrupt later data

so you could

int arr[0] = { 1 };

and boom :-)

Improve this answer

9 Comments

Can i do like int a[0] , then a[0] = 1 a[1] = 2 ??
@SurajJain If you want to overwrite your stack :-) C doesn't check the index vs the size of the array you are writing, so you can a[100000] = 5 but if you are lucky you'll simply crash your app, if you are lucky :-)
Int a[0] ; means a variable array (zero sized array) , How Can I Now assign it
@SurajJain What part of "C doesn't check the index vs the size of the array you are writing" isn't clear? There is no index checking in C, you can write after the end of the array and crash the computer or overwrite precious bits of your memory. So if you have an array of 0 elements, you can write after the end of the 0 elements.
See This quora.com/…
|
7

Zero-size array declarations within structs would be useful if they were allowed, and if the semantics were such that (1) they would force alignment but otherwise not allocate any space, and (2) indexing the array would be considered defined behavior in the case where the resulting pointer would be within the same block of memory as the struct. Such behavior was never permitted by any C standard, but some older compilers allowed it before it became standard for compilers to allow incomplete array declarations with empty brackets.

The struct hack, as commonly implemented using an array of size 1, is dodgy and I don't think there's any requirement that compilers refrain from breaking it. For example, I would expect that if a compiler sees int a[1], it would be within its rights to regard a[i] as a[0]. If someone tries to work around the alignment issues of the struct hack via something like

 typedef struct { uint32_t size; uint8_t data[4]; // Use four, to avoid having padding throw off the size of the struct }

a compiler might get clever and assume the array size really is four:

 ; As written foo = myStruct->data[i]; ; As interpreted (assuming little-endian hardware) foo = ((*(uint32_t*)myStruct->data) >> (i << 3)) & 0xFF;

Such an optimization might be reasonable, especially if myStruct->data could be loaded into a register in the same operation as myStruct->size. I know nothing in the standard that would forbid such optimization, though of course it would break any code which might expect to access stuff beyond the fourth element.

Improve this answer

5 Comments

The flexible array member was added to C99 as a legitimate version of the struct hack
The Standard does say that accesses to different array members do not conflict, which would tend to make that optimization impossible.
@BenVoigt: The C language standard doesn't specify the effect of writing a byte and reading the containing a word simultaneously, but 99.9% of processors do specify that the write will succeed and the word will contain either the new or old version of the byte along with the unaltered contents of the other bytes. If a compiler targets such processors, what would be the conflict?
@supercat: The C language standard guarantees that simultaneous writes to two different array elements won't conflict. So your argument that (read while write) works ok, is not sufficient.
@BenVoigt: If a piece of code were to e.g. write to array elements 0, 1, and 2 in some sequence, it would not be allowed to read all four elements into a long, modify three, and write back all four, but I think it would be allowed to read all four into a long, modify three, write back the lower 16 bits as a short, and bits 16-23 as a byte. Would you disagree with that? And code which only needed to read elements of the array would be allowed to simply read them into a long and use that.
3

Definitely you can't have zero sized arrays by standard, but actually every most popular compiler gives you to do that. So I will try to explain why it can be bad

#include <cstdio> int main() { struct A { A() { printf("A()\n"); } ~A() { printf("~A()\n"); } int empty[0]; }; A vals[3]; }

I am like a human would expect such output:

A() A() A() ~A() ~A() ~A()

Clang prints this:

A() ~A()

GCC prints this:

A() A() A()

It is totally strange, so it is a good reason not to use empty arrays in C++ if you can.

Also there is extension in GNU C, which gives you to create zero length array in C, but as I understand it right, there should be at least one member in structure prior, or you will get very strange examples as above if you use C++.

Improve this answer

1 Comment

If you're going to write C++, then use std::array<int, 0> empty which is completely legal and portabe.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.