Question

I do not understand the output of the following program:

#include <iostream>

#define FOO std::cout << __LINE__ << ' ' \
                      << __LINE__ << '\n';
int main()
{
    FOO

    std::cout << __LINE__ << ' ' \
              << __LINE__ << '\n';
}

The first output is 7 and 7, indicating that the expansion of FOO is a single logical line, but the second output is 9 and 10, indicating two distinct logical lines. Why is there a difference?

Answer 1

Because

1:  #include <iostream>
2: 
3:  #define FOO std::cout << __LINE__ << ' ' \
4:                        << __LINE__ << '\n';
5:  int main()
6:  {
7:      FOO // the first two __LINE__s come from here, that's one line of code
8: 
9:      std::cout << __LINE__ << ' ' \ // 3rd __LINE__ comes from here
10:              << __LINE__ << '\n'; // 4th __LINE__ comes from here
11: }

__LINE__ expands to physical lines, not logical lines:

The line number of the current source line is one greater than the number of new-line characters read or introduced in translation phase 1 (2.2) while processing the source file to the current token.

While the lines ended by \ are concatenated in translation phase 2.

The other only logical implementation would be to print 3 and 4 for the invocation of FOO, but that seems not very useful.

You can also look at this the following way: __LINE__ is not any different from any other macro. It’s just updated automatically by the compiler at the beginning of every line. So the code is kind of interpreted this way:

#include <iostream>

#define __LINE__ 3
#define FOO std::cout << __LINE__ << ' ' \
                      << __LINE__ << '\n';
int main()
{
#define __LINE__ 7
    FOO

#define __LINE__ 9
    std::cout << __LINE__ << ' ' \ // Yeah, you're right
#define __LINE__ 10
             << __LINE__ << '\n';
}

This is not valid code, but it demonstrates how the things work. Apply the usual macro expansion rules and you’ll get the output you’ve got.