Reliably determine the number of elements in an array

by

Is my usage of assert as the left operand of the comma expression valid standard C? That is, does the standard allow me to use assert as an expression?

Yes, it is valid as the left operand of the comma operator can be an expression of type void. And assert function has void as its return type.

My C compiler thinks that int b[NUM_ELEMS(a)]; is a VLA. Any way to convince him otherwise?

It believes so because the result of a comma expression is never a constant expression (e..g, 1, 2 is not a constant expression).

EDIT1: add the update below.

I have another version of your macro which works at compile time:

#define NUM_ELEMS(arr)                                                 \
 (sizeof (struct {int not_an_array:((void*)&(arr) == &(arr)[0]);}) * 0 \
  + sizeof (arr) / sizeof (*(arr)))

and which seems to work even also with initializer for object with static storage duration.
And it also work correctly with your example of int b[NUM_ELEMS(a)]

EDIT2:

to address @DanielFischer comment. The macro above works with gcc without -pedantic only because gcc accepts :

(void *) &arr == arr

as an integer constant expression, while it considers

(void *) &ptr == ptr

is not an integer constant expression. According to C they are both not integer constant expressions and with -pedantic, gcc correctly issues a diagnostic in both cases.

To my knowledge there is no 100% portable way to write this NUM_ELEM macro. C has more flexible rules with initializer constant expressions (see 6.6p7 in C99) which could be exploited to write this macro (for example with sizeof and compound literals) but at block-scope C does not require initializers to be constant expressions so it will not be possible to have a single macro which works in all cases.

EDIT3:

I think it is worth mentioning that the Linux kernel has an ARRAY_SIZE macro (in include/linux/kernel.h) that implements such a check when sparse (the kernel static analysis checker) is executed.

Their solution is not portable and make use of two GNU extensions:

  • typeof operator
  • __builtin_types_compatible_p builtin function

Basically it looks like something like that:

#define NUM_ELEMS(arr)  \
 (sizeof(struct {int :-!!(__builtin_types_compatible_p(typeof(arr), typeof(&(arr)[0])));})  \
  + sizeof (arr) / sizeof (*(arr)))

More Related Contents:

  1. How to find the ‘sizeof’ (a pointer pointing to an array)?
  2. Getting the size of a malloc only with the returned pointer
  3. C – SizeOf Pointers
  4. C pointers and arrays/ ‘sizeof’ operator [duplicate]
  5. How to find the size of an array (from a pointer pointing to the first element array)?
  6. C array pointer increment
  7. Pointers program
  8. Is an array name a pointer?
  9. With arrays, why is it the case that a[5] == 5[a]?
  10. How come an array’s address is equal to its value in C?
  11. Returning an array using C
  12. What does sizeof(&array) return?
  13. In C, are arrays pointers or used as pointers?
  14. Why does a C-Array have a wrong sizeof() value when it’s passed to a function? [duplicate]
  15. Exceptions to array decaying into a pointer?
  16. Why do arrays in C decay to pointers?
  17. Difference between char *str=”STRING” and char str[] = “STRING”?
  18. Pointer address in a C multidimensional array
  19. C – Difference between “char var[]” and “char *var”?
  20. Changing array inside function in C
  21. Literal string initializer for a character array
  22. Are a, &a, *a, a[0], &a[0] and &a[0][0] identical pointers?
  23. When is an array name or a function name ‘converted’ into a pointer ? (in C)
  24. Why can’t I treat an array like a pointer in C?
  25. Pointer to 2D arrays in C
  26. What’s the difference between array and &array?
  27. How to calculate size of array from pointer variable?
  28. Pointer expressions: **ptr++, *++*ptr and ++**ptr use
  29. Find size of array without using sizeof
  30. C pointer notation compared to array notation: When passing to function

Leave a Comment