如何在 cpp 中定义一个宏来打印文件 function 行？

Question

I am trying to make a print function which prepends the print statement with file, function, and line number.

The function debug("test %d", 1) should print:

[src/main.cpp:main():8] test 1

This answer claims to do what I want, and almost does it, but doesn't work as-is. (And the question is not the same as this one) Using that answer, I was able to come up with this macro:

#include <cstdio>  //needed for printf
#define debug(a, args...) printf("[%s:%s():%d] " #a "\n", __FILE__, __func__ , __LINE__, ##args)

This is extremely close to what I want, but adds quotes around the string, like below. How can I print without the quotes?

[src/main.cpp:main():8] "test 1"

Answer 1

There are 2 problems with your macro definition:

1. It uses incorrect syntax
2. The name of a variable may be passed as a ; in this case you cannot simply put the variable next to 2 string literals to do a concatenation.

The latter problem can be solved by using a string and the + operator or simply using multiple printf s.

If C++20 __VA_OPT__ is available, the following solution could be used.

#include <cstdio>
#include <utility>

namespace Logging
{
    template<typename ...Args>
    inline void Debug(size_t lineNumber, char const* filename, char const* functionName, char const* format, Args&&... args)
    {
        std::printf("[%s:%s():%zu] ", filename, functionName, lineNumber);
        std::printf(format, std::forward<Args>(args)...);
        std::printf("\n");
    }
}

#define debug(format, ...) ::Logging::Debug(__LINE__, __FILE__, __func__, format __VA_OPT__(,) __VA_ARGS__)

Pre C++ 20 you could create a helper object to deal with the case of a sue of the macro with just a single parameter

#include <cstdio>
#include <utility>

namespace Logging
{
    class Logger
    {
    public:
        Logger(size_t lineNumber, char const* filename, char const* functionName, char const* format)
            : m_lineNumber(lineNumber), m_filename(filename), m_functionName(functionName), m_format(format)
        {}

        template<class ...Args>
        inline void Debug(Args&&... args)
        {
            std::printf("[%s:%s():%zu] ", m_filename, m_functionName, m_lineNumber);
            std::printf(m_format, std::forward<Args>(args)...);
            std::printf("\n");
        }
    private:
        size_t m_lineNumber;
        char const* m_filename;
        char const* m_functionName;
        char const* m_format;
    };
}

#define debug(format, ...) ::Logging::Logger(__LINE__, __FILE__, __func__, format).Debug(__VA_ARGS__)

Answer 2

Replace #a with just a :

#define debug(a, args...) printf("[%s:%s():%d] " a "\n", __FILE__, __func__, __LINE__, ##args)

A single # followed by a macro parameter stringifies the parameter. IOW, it takes whatever the caller passes into the parameter and makes a string literal out of it. For example:

#define macro(a) #a

macro(1) would be "1" , macro(x+y) would be "x+y" , etc.

If the parameter contains quote characters, they will be stored as actual characters in the string literal, which is not what you want in this situation. Your parameter is being passed a string literal that you want to use as-is, so simple macro replacement will suffice, so you need to drop the # . You want the compiler to see "[%s:%s():%d] " "test %d" "\n" and thus merge them together into "[%s:%s():%d] test %d\n" , not to see "[%s:%s():%d] " "\"test %d\"" "\n" and merge them into "[%s:%s():%d] \"test %d\"\n" , which is what you are seeing happen in your original code.