在C语言的函数标头（声明/定义）中使用#define预处理程序指令可以吗？

Question

I'm currently working on some project as a C Developer in a company, and in our code there are many large function declarations for a different types of handling (such as state machine callbacks, event callbacks, timers etc.) and every type of handler declaration has the same semantics, for example event handler: static void onEvent1(Event event, EventArgs *args); .

There can be very big amount of such handlers and with many parameters in brackets, so I've decided to replace it with a small macro to increase readability and ease code writing like this: #define EVENT_HANDLER(funcName) static void funcName(Event event, EventArgs *args)

So the example code would look like this:

without #define :

static void onEvent1(Event event, EventArgs *args);
static void onEvent2(Event event, EventArgs *args);
static void onEvent3(Event event, EventArgs *args);

with #define :

EVENT_HANDLER(onEvent1);
EVENT_HANDLER(onEvent2);
EVENT_HANDLER(onEvent3);

After I've added changes to a code with such macro, I've heard a lot of critics from my colleagues in my address with no clear reason why it is not good. I've googled for an answer, and as far as I understand, such text replacing macro can do no harm nor lower code understanding. So, can somebody bring a clarity to me: is it really a bad habit to use #define in such a way, or no, and most impornantly: WHY?

thanks)

Answer 1

You can just use a regular typedef to be type safe. It avoids the pitfalls of the pre-processor and doesn't require inventing your own language within a language. Your colleagues have a point.

typedef void EventCB(Event, EventArgs *);

And use it as you'd expect:

static EventCB onEvent1;
static EventCB onEvent2;
static EventCB onEvent3;

You'll need to repeat the prototype when defining the functions, but the compiler will do type checking and warn you of any mistakes. Another plus of working with the type system, is the ability to use the same type to declare pointers:

EventCB *func_ptr = &onEvent1;