How can I use " sizeof " in a preprocessor macro?

In C or C++, sizeof is a compile-time operator used to determine the number of bytes occupied by a variable or data type in memory. Preprocessor macros are processed by the preprocessor before compilation and lack knowledge of C/C++ type information or variables.

Therefore, directly using sizeof within macros is impossible because the preprocessor does not execute or understand such compile-time operations. It only handles text substitution and does not parse or execute code. However, it can be indirectly combined with sizeof through macros to improve code readability and reusability.

Example

Suppose we want to design a macro for calculating the number of elements in an array:

c
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

This macro utilizes sizeof to compute the total number of bytes in the array, then divides by the number of bytes for a single element to obtain the count of elements. Here, sizeof is not computed by the preprocessor but is deferred to the compilation stage.

Usage Example

c
#include <stdio.h>

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

int main() {
    int array[] = {1, 2, 3, 4, 5};
    printf("Array size: %zu\n", ARRAY_SIZE(array));
    return 0;
}

When compiled and run, this program correctly outputs the array size as 5.

Notes

• This method is only valid for actual arrays defined as arrays. If a pointer rather than an actual array is passed to the macro, the result will be incorrect because the size of a pointer is typically fixed (e.g., 8 bytes on 64-bit systems), not the actual size of the array.
• Macros should avoid introducing side effects when used, such as performing complex or side-effecting operations within the macro.

Overall, although the preprocessor itself does not parse sizeof, we can cleverly design macros to leverage sizeof during compilation to enhance code reusability and maintainability.