Multi line preprocessor macros

Question

How to make multi line preprocessor macro? I know how to make one line:

#define sqr(X) (X*X)

but I need something like this:

#define someMacro(X)
    class X : public otherClass
    {
         int foo;
         void doFoo();
    };

How can I get this to work?

This is only an example, the real macro may be very long.

Answer 1

You use \ as a line continuation escape character.

#define swap(a, b) {               \
                       (a) ^= (b); \
                       (b) ^= (a); \
                       (a) ^= (b); \
                   }

EDIT: As @abelenky pointed out in the comments, the \ character must be the last character on the line. If it is not (even if it is just white space afterward) you will get confusing error messages on each line after it.

Answer 2

You can make a macro span multiple lines by putting a backslash (\) at the end of each line:

#define F(x) (x)   \
              *    \
             (x)

Answer 3

PLEASE NOTE as Kerrek SB and coaddict pointed out, which should have been pointed out in the accepted answer, ALWAYS place braces around your arguments. The sqr example is the simple example taught in CompSci courses.

Here's the problem: If you define it the way you did what happens when you say "sqr(1+5)"? You get "1+51+5" or 11
If you correctly place braces around it, #define sqr(x) ((x)(x))
you get ((1+5) * (1+5)) or what we wanted 36 ...beautiful.

Ed S. is going to have the same problem with 'swap'

NOTE - Ed S. edited his answer after this post.

Answer 4

You need to escape the newline at the end of the line by escaping it with a \:

#define sqr(X) \
        ((X)*(X))

Answer 5

Although this wasn't part of the original question, none of the other answers mention that comments embedded in multi-line macros require careful attention.

• C++ style comments may not appear on any line having a line continuation escape character.
• C-style comments may not span multiple lines separated by a line continuation escape character.

Examples:

// WRONG:
#define someMacro(X)          \
// This comment is a problem. \
class X : public otherClass   \
{                             \
     int foo;                 \
     void doFoo();            \
};

---

// WRONG:
#define someMacro(X)        \
/* This comment is also     \
 * a problem. */            \
class X : public otherClass \
{                           \
     int foo;               \
     void doFoo();          \
};

---

// OK:
#define someMacro(X)                \
/* This comment is fine. */         \
class X : public otherClass         \
{                                   \
     int foo; /* This is OK too! */ \
     void doFoo();                  \
};

Answer 6

This is 2021 and we should really be moving towards inline. Incorrect, unnecessary and overuse of macros bloats the code and they are hard to debug ( read really hard to debug )

inline void foo(x)
{
   // do whatever with x
}

if, however macros are really the need of the hour, surrounding them with a do { } while(0); reason is explained in this post Why use apparently meaningless do-while and if-else statements in macros?