预处理器定义与函数原型的使用

Question

I have to deal with two header files declaring the same prototype with different type name (note that the 2 types are the same at the end)

One of them is protected with #ifndef directive

I am considering adding a define to avoid the double declaration but have been told is not good practice to have the same name for a define definction and for a function name.

acg_header.h

    #ifndef ACos
    /* MATH::ACos/ */
    extern T_Float_user ACos(/* X/ */ T_Float_user X);
    #endif /* ACos */

manual_header.h

    #define ACos // suggested modification
    extern t_float ACos(const t_float X);

I would like to know if is is a correct solution regarding C implementation.

Answer 1

You may have any number of compatible declarations of the same function or object. It is not necessary or useful to play preprocessor games to avoid this situation. This is why the standard approach is for each function or global variable to be declared in a (one) header file, and for each source that accesses or defines any function or object to include the appropriate header. So, with respect to

I have to deal with two header files declaring the same prototype with different type name

, no, you shouldn't have to deal with that. There should be only one header declaring each function. Nevertheless, if you do have two, and they declare the function compatibly, then you still have no problem, even if the declarations do not lexically match on account of the use of different -- but compatible -- type aliases.

If the declarations in your two header files are not compatible with each other, on the other hand, then you have a deeper problem. At most one of them can be compatible with the function definition, and you must not use any other.

I am considering adding a define to avoid the double declaration but have been told is not good practice to have the same name for a define definction and for a function name.

Again, your best bet is to skip this whole exercise, but if you choose to go ahead, then you need to understand that appearances in your code of an in-scope macro identifier will be replaced with the macro definition. Thus, the result of preprocessing this:

 #define ACos // suggested modification extern t_float ACos(const t_float X);

would be

extern t_float (const t_float X);

, because you've defined ACos to expand to an empty sequence. The preprocessed result is invalid. If you must follow this path, then define the macro to expand to its own name:

#define ACos ACos

You will then be able to test it via #ifdef directives, but you will avoid causing the preprocessor to mangle your program. But again, really, don't do this at all.