Are there any good uses of macros? [closed]

Answer 1

Several uses (some may have been mentioned already..)

1. Logging: DEBUG(....), this is neat because the contents are only evaluated if the logging is active (so the macro could have a test for log level for example...) You cannot replace this with an inline function as the arguments will always be evaluated. However with c++11, there is a lambda trick which will avoid the evaluation, however the syntnax is cludgy so you'll end requiring a macro anyway to clean it up! :)
2. Code generation, I use lots of SFINAE tests, and it's easy to generate the test with a couple of macros rather than hand construct the test every time.

Answer 2

Prior to C++11, you would usually define static_assert as a macro (a typedef that would be invalid if the condition is false), so it can be available from anywhere (namespace level, or function level) and still not be ambiguous (e.g. by using a line number).

The Boost.Preprocessor library is another good example of using macros to reduce the amount of highly redundant code, and another one that is less relevant with variadic templates.

Furthermore macros are widely used to "talk" to the compiler, e.g. checking what compiler you are running on, what version of the compiler, whether C++11 support is available, etc.

Answer 3

Yes, the X-macro trick will always be useful.

You put your data in one header (no #include guards!), then use a macro to conditionally expand it.

Example:

Data.h:

X(Option1, "Description of option 1", int, long)
X(Option2, "Description of option 2", double, short)
X(Option3, "Description of option 3", wchar_t*, char *)

MyProgram.cpp:

enum Options
{
#define X(Option, Description, Arg1, Arg2) Option,
#   include "Data.h"
#undef X
};

char const *descriptions[] =
{
#define X(Option, Description, Arg1, Arg2) Description,
#   include "Data.h"
#undef X
};

#define X(Option, Description, Arg1, Arg2) typedef void (*P##Option)(Arg1, Arg2);
#   include "Data.h"
#undef X

It's not the prettiest sight, but it avoids code duplication and lets you keep everything in one place.

Answer 4

Macros can be defined from the compiler command line, with -DFOO, which would define the macro FOO. This is most often used for conditional compilation, e.g. a certain optimization that is known to work on some platforms but not on others. The build system can detect whether the optimization is viable an enable it using this kind of macro.

This is one of the few uses of macros that I believe can be used well. However, it's of course possible to abuse this feature as well.

Answer 5

Extending on the answer from @Matthieu, I've used macros to add file and line logging to a legacy codebase. So this:

void MovePlayer(Vector3 position)
{ 
    ...
}

became something like:

#define MovePlayer(pos) MovePlayer_(pos, __FILE__, __LINE__)

void MovePlayer_(Vector3 position, const char* file, int line)
{
    LogFunctionCall("MovePlayer", file, line);
    ...
}

By only changing one place in the codebase, I was able to log everywhere that the function got called during a complex test. If you do this to enough functions, it's very useful for tracing existing behaviour in old codebases.

Answer 6

Logging and Exception.

A macro allows you to effortlessly capture __FILE__, __LINE__ and __func__. Oh sure you could write them manually each time, but frankly this is tedious and error prone (both __FILE__ and __func__ are C-string so you risk mixing them up).