Macro definition ARRAY_SIZE
c, c++, macros
Solution
latter part will always evaluates to 1, which is of type size_t,
Ideally the later part will evaluate to `bool` (i.e. `true`/`false`) and using `static_cast<>`, it's converted to `size_t`.
why such promotion is necessary? What's the benefit of defining a macro in this way?
I don't know if this is ideal way to define a macro. However, one inspiration I find is in the comments: `//You should only use ARRAY_SIZE on statically allocated arrays.`
Suppose, if someone passes a pointer then it would fail for the `struct` (if it's greater than pointer size) data types.
struct S { int i,j,k,l };
S *p = new S[10];
ARRAY_SIZE(p); // compile time failure !
[Note: This technique may not show any error for `int*`, `char*` as said.]
Problem
I encountered the following macro definition when reading the globals.h in the Google V8 project. ``` // The expression ARRAY_SIZE(a) is a compile-time constant of type // size_t which represents the number of elements of the given // array. You should only use ARRAY_SIZE on statically allocated // arrays. #define ARRAY_SIZE(a) \ ((sizeof(a) / sizeof(*(a))) / \ static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) ``` My question is the latter part: `static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))`. One thing in my mind is the following: Since the latter part will always evaluates to `1`, which is of type `size_t`, the whole expression will be promoted to `size_t`. If this assumption is correct, then there comes another question: since the return type of `sizeof` operator is size_t, why is such a promotion necessary? What's the benefit of defining a macro in this way?