What is the reason to #define and #undefine a macro in an array initializer?

Question

I came across this code snippet. What's the purpose of #define and #undef a macro in an array initializer ?

#define MY_ARR MACRO(30)\ 
               MACRO(40) 
int array[] = { 
#define MACRO(a) a, 
                10, 
                20, 
             MY_ARR 
#undef MACRO 
};

Where did you find such stuff? Without more context it doesn't make much sense. — Gerhardh, Jun 30 '20 at 08:19
Are you sure there was no use of `MACRO` at all in the code you found? — Gerhardh, Jun 30 '20 at 08:20
Guys, even i felt it's senseless before posting. But, the developer who wrote this code might have something in his mind. So, thought of checking with our community, if they can sense something. Thanks for your time guys. — ERROR, Jun 30 '20 at 09:02
@ERROR It's not finished yet! Provide some more information. If possible, cite the source explicitly, so we can take a look at it. — RobertS supports Monica Cellio, Jun 30 '20 at 09:11
@ERROR And is the shown snippet exactly equivalent to the source? — RobertS supports Monica Cellio, Jun 30 '20 at 09:14
Often these kind of mysteries can be solved by looking at version control history. Perhaps something was removed at some point, and remaining code was left unused. — user694733, Jun 30 '20 at 09:56
Guys, pls accept my apologies. Here is the equivalent source code. #define MY_ARR MACRO(30)\ MACRO(40) int array[] = { #define MACRO(a) a, 10, 20, MY_ARR #undef MACRO }; — ERROR, Jul 27 '20 at 06:50
@ERROR those are called X-macros, they're useful **only** if `MY_ARR` is used in **many** places... Also, if the `10, 20,` are on *separate lines* as in your example, it'd be better to just `#define MACRO(a)` just before `MY_ARR` is used. — Antti Haapala, Jul 27 '20 at 07:38

Paul Ogilvie · Answer 1 · 2020-06-30T08:29:20.840

0

MACRO will only be known between its #define and its #undef

As MACRO is never used within its defined scope, it does nothing, so the result is

int array[]= {10, 20,};

edited Jun 30 '20 at 08:29

answered Jun 30 '20 at 08:21

Paul Ogilvie

24,146
4
18
39

some compilers accept the extra "," in the end, though – Jean-François Fabre Jun 30 '20 at 08:25
@Jean-FrançoisFabre, I just found out: MS VC2008 – Paul Ogilvie Jun 30 '20 at 08:27
2

"Note that this has a syntax error because there is a , too many at the end of the initializer list." That's not a syntax error. C has always allowed trailing comma at the end of an initializer list. C90 didn't allow trailing comma for enums though. This was fixed in C99, making initializer lists and enums consistent. These trailing comma rules are important when writing more obscure stuff like X macros. – Lundin Jun 30 '20 at 08:28
@Lundin, thanks for the explanation. Still sounds as a syntax error to me ("syntax hack") – Paul Ogilvie Jun 30 '20 at 08:30
Specifically, C11 6.7.9: _initializer:_ ... `{` _initializer-list_ `}` ... `{` _initializer-list_ `, }` – Lundin Jun 30 '20 at 08:32
@PaulOgilvie https://stackoverflow.com/questions/23466831/c-is-this-array-initialization-legal/23467102#23467102 – RobertS supports Monica Cellio Jun 30 '20 at 08:45
@PaulOgilvie https://stackoverflow.com/questions/2311864/history-of-trailing-comma-in-programming-language-grammars – RobertS supports Monica Cellio Jun 30 '20 at 08:50
For anyone who is interested in C++ equivalent - This is also the most popular question regarding trailing comma: https://stackoverflow.com/questions/7043372/int-a-1-2-weird-comma-allowed-any-particular-reason – RobertS supports Monica Cellio Jun 30 '20 at 08:50
question has been edited. – Antti Haapala Jul 27 '20 at 07:36

score 0 · Answer 2 · answered Jun 30 '20 at 08:26

0

There is no reason, the code is senseless. Since the macro is defined, immediately undefined and never called, this expands to:

int array[]= { 10, 20, };

answered Jun 30 '20 at 08:26

Lundin

155,020
33
213
341

yeah, I know :) old C answer habits die hard – Jean-François Fabre Jun 30 '20 at 08:27
it has been edited... – Antti Haapala Jul 27 '20 at 07:36

RobertS supports Monica Cellio · Answer 3 · 2020-06-30T09:49:55.223

This function-like macro definition has no use because it is indeed not used anywhere in the array initializer until its undefinition at the end of the initializer list.

For example Clang complains this too:

"warning: macro is not used [-Wunused-macros]"

As result after the preprocessing, the code is equivalent to:

int array[] = { 10, 20, };

I guess the intention was to define a first element and initialize it with the value of a by the use of conditional compilation directives, so that array is composed of 3 elements instead of 2, with the first element containing the value of a.

This would be more appropriate for this case:

MACRO is defined before its use/check in the array initializer list. If it was defined, a is inserted into the initializer. Since MACRO has no further use, we can #undef it after the initialization.

#define MACRO 
#define a 5

int array[] = { 

    #ifdef MACRO 
        a,
    #endif
    #undef MACRO
        10,        
        20,        
};

Note: a could also be a const qualified integer object than a preprocessor macro: const int a = 5;.

1

It has been edited... – Antti Haapala Jul 27 '20 at 07:37

What is the reason to #define and #undefine a macro in an array initializer?

3 Answers3