What does a C array definition without size mean?

Example:

int main()
{
    int array[];
}

Is it just an uninitialized pointer? Or an array with a small default size?

Which compilers support this syntax, and why? I see this as a recipe for confusion.

Also mentioned here:

https://stackoverflow.com/q/76032903/509868

<!-- please let me continue -->

For this declaration to be valid, there needs to be an initializer list present:
int array[] = { ... };.

Otherwise the array is incomplete, C17 6.7.6.2:

> If the size is not present, the array type is an incomplete type.

Incomplete array types at local scope are not valid declarations and a conforming compiler will raise a diagnostic message. Incomplete array types are only allowed in some special cases:

• A function declaration may contain an incomplete array type since it gets adjusted to a pointer to the first element. After adjustment, the array should not have incomplete type (nor be of an array type with incomplete element type).

  void func (int array[]) is therefore valid and equivalent to void func (int* array).

• The last member of a struct can be an incomplete array type, a so-called flexible array member.

• As a file scope array declared outside any function, with its type completed later in the same translation unit or when it has external linkage (extern etc), referring to an array in another translation unit.

As other answers indicate, the code is illegal in C in that context.

However, if the declaration includes initialization, then the array has proper size:

int array[] = {10, 20, 30}; // array has size 3

A special case is when the initialization is empty:

int array[] = {}; // array has size 0

In this case, the size of the array is 0. This is not allowed in C, but some compilers support this.

int main()
{
    int array[] = {};
    printf("%zu", sizeof(array));
}

Compiled by gcc: OK, prints 0

Compiled by gcc -pedantic: error: zero or negative size array

Compiled by MS Visual Studio: error: cannot allocate an array of constant size 0

A zero-size array is mostly useless; it provides the same functionality as flexible array member, but is non-standard — only supported for compatibility with some old code.

The construct int array[]; as it appears in your code (in other words: as a stand-alone array) is illegal in C.

Supposing it were legal:

Q: Is it just an uninitialized pointer?

A: an array is not a pointer. If such a declaration were legal it would be an array of size zero. And if you'd assign array to a pointer, the pointer would point to a segment of memory of size 0. BTW latter is actually possible by using malloc(0), but that's another story.

Q: Is it an array with a small default size?

A: Not there are no default sizes in C. BTW what would that default size be?

Q: Which compilers support this syntax, and why?

A: AFAIK no sane C compiler supports this for a good reason.

int array[]; declares array with an incomplete array type.

Inside a function (i.e. at block scope), a declaration of a variable that is not declared extern, and that has no initializer, but is declared with an incomplete array type is not allowed.

Outside a function (i.e. at file scope), a declaration of a variable that is not declared extern, and that has no initializer, but is declared with an incomplete array type is allowed as a tentative definition of the variable. If the variable's type is still incomplete at the end of translation unit (i.e. at the end of the current compilation), it will be implicitly initialized with the initializer {0} causing it to have one element (but its size cannot be measured with sizeof because the type is still incomplete at the point where sizeof is used).

> I see this as a recipe for confusion

Which is exactly why this is not allowed by design in the language. So no compiler will support this. The array must be known in size either by providing a size in the array declaration, or by immediate initialization so the size can be derived.

https://en.cppreference.com/w/cpp/language/array#Arrays_of_unknown_bound