使用宏强制转换pthread的start_routine参数

Question

I'm trying to understand some code I've been given. It works in a similar way to pthread_create : you pass it a pointer to a function start_routine which takes a pointer to void arg as the single argument, and the argument pointer itself, and then pthread_create calls your function.

Generally, if start_routine actually needs an argument, it does not need a void * , but rather arg should be cast to a pointer to some struct. In the past, I've coded my start_routine s like this:

void *my_start_routine(void *arg)
{
    struct my_struct *p = arg;
    // use p many times
}

However, I just received code where the author sets up a macro to do the cast every time p is used:

void *my_start_routine(void *arg)
{
#define p ((struct my_struct *) arg)
    // use p many times

#undef p
}

I'm having a hard time understanding why you'd want to do this. But I assume it is deliberate, because it seems more difficult and less obvious than the first way, and the author uses similar idioms throughout the code. Is there some reason, performance or otherwise, to prefer the macro here?

Answer 1

Your idiom is preferable; the other person's with the macro is, in my opinion, an abomination, for reasons like:

• p is not an lvalue
• It's non-obvious that changes to arg affect p .
• The debugger won't have any idea what p is.
• ...

Answer 2

The only possible difference I could see would be that no space would be allocated on the stack for p , but this is a rather dubious optimisation, since it's done only once at the start of the function, and may well be optimised out by the compiler any way.

I tend to use the preprocessor only for very simple substitutions nowadays since macros can be better done as inline functions (or compilers doing their own optimisations) and grouped constants (like error codes) are better as enumerations.