C++ void cast and operator comma in a #define

Question

I found this while reading some source code.

 #define MACRO(x)  if((void) 0, (x)); else some_func();

I don't fully understand the reasons behind that operator comma and the void cast. This has probably something to do with macro protection, I know that (void)0 is used sometimes to protect cascading elses in macros such as in if(...) then foo(); else (void)0.

Any ideas of why operator comma is there?

edit: I'm starting to think this has something to do with the owl (0,0).

Answer 1

The void conversion there is definitely to prevent calling an overloaded operator , since you can't overload with a void parameter. This guarantees that (void)0, has no effect.

Why the comma operator is there? A good question. I really don't know.

Answer 2

This looks a bit as if somebody may have started with some code that included an assert, pre-processed it, and turned the result into a macro. When NDEBUG is defined, assert has to turn into nearly nothing -- but, syntactically, still has to produce some placeholder code. For example, you're allowed to use it in a situation like:

assert(x), *x = 1;

When you compile this with NDEBUG defined, it still needs to compile, but the assert shouldn't do anything. To support that, assert is typically defined something like this:

#undef assert
#ifdef NDEBUG
#define assert(x) ((void)0)
#else
#define assert(x) ((!!x) || __failassert(x, __FILE__, __LINE__))
#endif 

So, if somebody started with code like above, and then looked at the preprocessed version (with NDEBUG defined), they'd see something like:

((void *)0), *x = 1;

...and if they didn't understand the code very well, they might think that ((void)0) really meant/accomplished something.

Answer 3

I would guess that the trick is used to prevent the user form declaring variables in the if condition. As you probably know, in C++ it is legal to do this

if (int i = some_func()) {
   // you can use `i` here
}
else  {
   // and you can use `i` here
}

The use of comma operator in that definition will prevent macro usage like

MACRO(int i = some_func());

and force the user to use only expressions as argument.