How to generate a newline in a cpp macro?

Question

How do I write a cpp macro which expands to include newlines?

Answer 1

Not quite sure what you're asking here. Do you want a macro on multiple lines?

#define NEWLINE_MACRO(x) line1 \
line2 \
line3

Additionally, if you would like to include a literal in your macro:

#define NEWLINE_MACRO(x) ##x

what you you put in x will be put in place of ##x, so:

NEWLINE_MACRO( line1 ) // is replaced with line1

This can be helpful for making custom global functions then just need part of the function name changed.

Also:

#define NEWLINE_MACRO(x) #x // stringify x

Will put quotes around x

Answer 2

The C compiler is aware of white space, but it doesn't distinguish between spaces, tabs or new lines.

If you mean how do I have a new line inside a string in a macro, then:

#define SOME_STRING "Some string\n with a new line."

will work.

Answer 3

C & C++ compilers ignore unquoted whitespace (except for the > > template issue), so getting a macro to emit newlines doesn't really make sense. You can make a macro span several lines by ending each line of the macro with a backslash, but this doesn't output newlines.

Answer 4

Use \, like so:

#define my_multiline_macro(a, b, c) \
if (a) { \
    b += c; \
}

Answer 5

I am working on a large project that involves a lot of preprocessor macro functions to synthesize any code that cannot be replaced by templates. Believe me, I am familiar with all sorts of template tricks, but as long as there is no standardized, type safe metaprogramming language that can directly create code, we will have to stick with good old preprocessor and its cumbersome macros to solve some problems that would require to write ten times more code without. Some of the macros span many lines and they are very hard to read in preprocessed code. Therefore, I thought of a solution to that problem and what I came up with is the following:

Let's say we have a C/C++ macro that spans multiple lines, e.g. in a file named MyMacro.hpp

// Content of MyMacro.hpp

#include "MultilineMacroDebugging.hpp"

#define PRINT_VARIABLE(S) \
__NL__  std::cout << #S << ": " << S << std::endl; \
__NL__  /* more lines if necessary */ \
__NL__  /* even more lines */

In every file where I defined such a macro, I include another file MultilineMacroDebugging.hpp that contains the following:

// Content of MultilineMacroDebugging.hpp

#ifndef HAVE_MULTILINE_DEBUGGING
#define __NL__
#endif

This defines an empty macro __NL__, which makes the __NL__ definitions disappear during preprocessing. The macro can then be used somewhere, e.g. in a file named MyImplementation.cpp.

// Content of MyImplementation.cpp

// Uncomment the following line to enable macro debugging
//#define HAVE_MULTILINE_DEBUGGING

#include "MyMacro.hpp"

int a = 10;
PRINT_VARIABLE(a)

If I need to debug the PRINT_VARIABLE macro, I just uncomment the line that defines the macro HAVE_MULTILINE_DEBUGGING in MyImplementation.cpp. The resulting code does of course not compile, as the __NL__ macro results undefined, which causes it to remain in the compiled code, but it can, however, be preprocessed.

The crucial step is now to replace the __NL__ string in the preprocessor output by newlines using your favorite text editor and, voila, you end up with a readable representation of the result of the replaced macro after preprocessing which resembles exactly what the compiler would see, except for the artificially introduced newlines.

Answer 6

It is not possible. It would only be relevant if you were looking at listing files or pre-processor output.

A common technique in writing macros so that they are easier to read is to use the \ character to continue the macro onto a following line.

I (believe I) have seen compilers that include new lines in the expanded macros in listing output - for your benefit. This is only of use to us poor humans reading the expanded macros to try to understand what we really asked the compiler to do. it makes no difference to the compiler.

The C & C++ languages treat all whitespace outside of strings in the same way. Just as a separator.