Are there any good uses of macros? [closed]

Answer 1

Yes, they will still have uses such as for "message maps" in ATL, WTL, MFC.

For example, this is part of some personal code I have:

BEGIN_MSG_MAP(This)
    MESSAGE_HANDLER(WM_CLOSE, OnClose)
    MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
    MESSAGE_HANDLER(WM_GETDLGCODE, OnGetDlgCode)
    COMMAND_RANGE_HANDLER(IDOK, IDNO, OnButtonClick)
    CHAIN_MSG_MAP(CDialogResize<This>)
END_MSG_MAP()

Or even specifying the layout of a window:

BEGIN_DLGRESIZE_MAP(This)
    DLGRESIZE_CONTROL(IDOK, DLSZ_MOVE_X)
    DLGRESIZE_CONTROL(IDCANCEL, DLSZ_MOVE_X)
    DLGRESIZE_CONTROL(IDC_EDITINPUT, DLSZ_SIZE_X)
END_DLGRESIZE_MAP()

Writing this without macros would involve a lot of unnecessary boilerplate code.

Answer 2

The macros are considered error prone due to its characteristics, here we have some good examples of error prone macros:

• Macros VS inline functions.
• Macros containing if.
• Multiple line macros.
• Concatenation macros.

But they could be useful in some ways, for example, in order to make te code more readable when dealing with function pointers:

class Fred {
public:
    int f(char x, float y);
    int g(char x, float y);
    int h(char x, float y);
    int i(char x, float y);
    // ...
};

// FredMemberFn points to a member of Fred that takes (char,float)
typedef  int (Fred::*FredMemberFn)(char x, float y);

// Useful macro:
#define callMemberFunction(object,ptrToMember)  ((object).*(ptrToMember))

With the "Useful macro", you can call function pointers like this:

callMemberFunction(fred,memFn)('x', 3.14);

That is slightly more clear than:

(fred.*memFn)('x', 3.14);

Credits: C++ FAQ Lite.

Answer 3

When you need to utilize platform, compiler, or implementation specific features. Typically, this is either to improve portability or to access features which are expressed differently in the systems you target (i.e. it may be written differently on the compilers you use).

And expanding on Matthieu's answer (+1): Assertions.

Answer 4

Writing exception-checking tests with macros is much easier than with functions.

#define TEST_THROWS(code) do { try { code; } catch (...) { pass(); } fail(); } while(0)

Note: example not tested

Answer 5

There are some code rewriting for optimization that seem not to be doable with template metaprogramming and need macros. Here is a probable example: C++ template for unrolling a loop using a switch?