Interpretation of an 'Empty' C Array (int a = {};)

Question

I have a snippet of code that defines (what I believe to be) an empty array, i.e. an array containing no elements:

int a[] = {};

I compiled the snippet with gcc with no problem

A colleague attempting to get that same code to compile under MSVS made the modification:

int* a = NULL;

No he obviously thought that was an equivalent statemnent that would be acceptable to the MSVS compiler.

However, later in the code I retrieve the no. of elements in the array using the following macro:

#define sizearray(a)  (sizeof(a) / sizeof((a)[0]))

when doing so:

sizearray({}) returns 0

this is as I would expect for what I believe to be a definition of an empty array

sizearray(NULL) returns 1 

I'm thinking that sizeof(NULL)/sizeof((NULL)[0])) is actually 4/4 == 1

as NULL == (void*)0

My question is whether:

int a[] = {}; 

is a valid way of expressing an empty array, or whether its poor programming practice.

Also, is it the case that you can't use such an expression with the MSVS compiler, i.e. is this some sort of C99 compatibility issue?

UPDATE:

Just compiled this:

#include <stdio.h>

#define sizearray(a)  (sizeof(a) / sizeof((a)[0]))

int main()
{
    int a[] = {};
    int b[] = {0};
    int c[] = {0,1};

    printf("sizearray a = %lu\n", sizearray(a));
    printf("sizearray b = %lu\n", sizearray(b));
    printf("sizearray c = %lu\n", sizearray(c));

    return 0;
}

using this Makefile:

array: array.c
    gcc -g -o array array.c

My compiler is:

gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.9) 

compiles without any complaint, output looks like this:

bph@marvin:~/projects/scratch/c/array$ ./array
sizearray a = 0
sizearray b = 1
sizearray c = 2

very curious? could it secretly be a C++ compiler, not a C compiler?

Tried John Bodes suggestion of additional compiler flags and can confirm that the compilation does then fail:

gcc --std=c11 --pedantic -Wall -g -o array array.c
array.c: In function ‘main’:
array.c:7:15: warning: ISO C forbids empty initializer braces [-Wpedantic]
     int a[] = {};
               ^
array.c:7:9: error: zero or negative size array ‘a’
     int a[] = {};
         ^
Makefile:2: recipe for target 'array' failed
make: *** [array] Error 1

Answer 1

Empty initializers are invalid in C. So

int a = {};

is ill-formed. See 6.7.9 Initialization.

sizearray(NULL) is not valid either. Because the sizearray macro would expand to:

sizeof 0 /sizeof 0[0])

If NULL is defined as 0. This is not valid because the 0[0] isn't valid because of there's no pointer or array involved (as required for pointer arithmetic - remember a[b] is equivalent to *(a + b)).

Or, it would expand to:

(sizeof(((void *)0)) / sizeof((((void *)0))[0]))

if NULL was as ((void*)0). This is not valid because pointer arithmetic is not allowed on void pointers. See 6.5.6, 2 and void* is an incomplete type. Similar issue be present for whatever the definition of NULL is in an implementation (C standard is flexible with the definition of null pointer constant i.e., NULL. See 7.19, 3).

So in both cases, what you see is compiler specific behaviours for non-standard code.

Answer 2

This is not an array, but it's not a scalar either: it's a syntax error.

The C11 draft says, in §6.7.9.11 (Initialization Semantics):

The initializer for a scalar shall be a single expression, optionally enclosed in braces. The initial value of the object is that of the expression (after conversion); the same type constraints and conversions as for simple assignment apply, taking the type of the scalar to be the unqualified version of its declared type.

But there has to be something between the braces, it can't be empty.

So I'd argue that the question is missing something, and this was not the actual code.

Answer 3

It's not an array, it's the brace initialization syntax.

Short word, you can write this:

int a = {1234};

It does not initialize a with an array, it just assigns 1234. If there are 2 or more values, that's be an error.

Brace initialization disables value truncating, so:

char b = 258; // Valid, same as b = 2
char b = {258}; // Wrong, can't truncate value in braces

And empty braces are just zero-initializers, so int a = {} is equivalent to int a = {0}