LOG macro that logs named variables

Question

In my code I use printf-like LOG(const char* fmt, ...) macro. Under the hood it prints/logs to different output destinations (file, console, debugger output). It's my own macro, so it does printf format when there are 2+ args, and logs strings as-is when only one argument is passed.

I want to update or extend it, so that it could take list args to log. So that it could work similar to console.log in javascript, except it would also log arg names. For example:

int64_t x = -1234;
unsigned volume = 10;
double pi = 3.1415926535;
const char* name = "test";
std::string str = "hello";

LOG(x, volume, pi, name, str);

should log something like that:

x:-1234, volume:10, pi:3.1415926535, name:test, str:hello

Are there some examples/libraries that do something like that? Note, I'm not limited on what c++ version to use (I use latest), but I will not use iostreams for sure.

This #define reference could be helpful to read. Pay close attention to the # and ## operators inside macro bodies. — Some programmer dude
– Some programmer dude, Commented May 17 at 13:32
This questions should have many answers, the correct ones will use variadic templates. But also, NEVER assume you can mimmick exactly what you know from one language (javascript) into another language (C++). In the end I think you should even decouple logging from your functional code alltogether (have a look at dependency injection) — Pepijn Kramer
– Pepijn Kramer, Commented May 17 at 13:40

Andrey Turkin · Accepted Answer · 2025-05-17 14:29:20Z

2

Main issue is on how to do for-each macro application primitive on variadic arguments. Here I'm going to use a method described here: https://www.scs.stanford.edu/~dm/blog/va-opt.html verbatim.

// Format single argument
#define LOG_1(x) #x ":" << x
#define LOG_2(x) << ", " << LOG_1(x)
#define LOG(var, ...) do { \
    std::cout << LOG_1(var) FOR_EACH(LOG_2 __VA_OPT__(,) __VA_ARGS__) << std::endl;  \
 } while(false)

See https://godbolt.org/z/eEnhd49h3 for a full example.

If you want std::format-based approach, that can be done fairly simply as well (arguably even simpler):

#define LOG(x) std::cout << x << std::endl
#define LOG_1(x) #x ":{}"
#define LOG_2(x) ", " LOG_1(x)
#define LOG_FORMAT(var, ...) LOG_1(var) FOR_EACH(LOG_2 __VA_OPT__(,) __VA_ARGS__)
#define LOG_ARGS(...) do { \
    LOG(std::format(LOG_FORMAT(__VA_ARGS__), __VA_ARGS__));  \
 } while(false)

https://godbolt.org/z/nb6YaGoch

Or, since you tagged Boost Preprocessor:

#define LOG_1(x) #x ":" << x
#define LOG_2(d, state, x) state ", " LOG_1(x) << 
#define LOG(var, ...) do { \
    std::cout << BOOST_PP_LIST_FOLD_LEFT(LOG_2, LOG_1(var) <<, BOOST_PP_VARIADIC_TO_LIST(__VA_ARGS__)) std::endl;  \
 } while(false)

Both of these need C++20 to handle single-argument case though (__VA_OPT__ support is needed).

edited May 17 at 14:29

answered May 17 at 14:14

Andrey Turkin

3,7861 gold badge14 silver badges26 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

Pavel P May 17 at 14:17

sorry I updated too late perhaps, I don't use iosrteams. printf is ok, std::format is also ok (I don't use it yet, but will start using it most likely). Check my approach I added.

Andrey Turkin May 17 at 14:33

Doesn't really matter, main thing is to find a way to apply a macro to each item in variadic arguments (which Boost PP gives you as you found out for yourself). Once you have that, you can apply whatever transformation needed to adapt to your needs. printf isn't really an option because you can't get a type of each element for its format string; std::format works just fine. I've edited my answer to add std::format based approach.

Pavel P May 17 at 15:12

my solution works with ms compiler only for some reason. It looks like std::format(std::vector) doesn't compiler with clang/gcc, but works with ms compiler. However, it works with your solution. No idea why.

Pavel P May 17 at 15:19

ok, I see now. It's c++23 to print vectors.

Andrey Turkin May 17 at 16:06

@PavelP It's not that much of a code tbh. However you might want to try the great fmt library (fmt.dev). It's a drop-in replacement, doesn't need C++23 for ranges, and call-site code is fairly tiny.

|

Solt · Accepted Answer · 2025-05-17 20:22:29Z

2

You can do something like this:

#define PAIR(name) #name, name

LOG( PAIR(var1), PAIR(var2) );
//compiler will convert it to
LOG( "var1", var1, "var2", var2 );

For type of variable you can add typeid(myint).name()

#define VAR_INFO(n) #n, typeid(n).name(), n

int var1;
double* var2;
LOG( VAR_INFO(var1), VAR_INFO(var2) );
//compiler will convert it to
LOG( "var1", "i", var1, "var2", "Pd", var2 );

Next step you should deal with variadic function implementation to get arguments, parse types and forward to printf. The main difficulty will be with very big number of types, including user-defined. I don't know how to prepare format string for printf out of this data.

edited May 17 at 20:22

answered May 17 at 13:56

Solt

1,5013 silver badges17 bronze badges

Comments

Pavel P · Accepted Answer · 2025-05-20 22:18:48Z

With modern c++ and boost::preprocessor, I made it working surprisingly quickly:

#include <boost/preprocessor.hpp>
#include <format>

#define LOGARGS_PAIR(r, data, elem) (", ")(BOOST_PP_STRINGIZE(elem) ":{}")
#define LOGARGS(...) LOG(std::format(BOOST_PP_SEQ_CAT(BOOST_PP_SEQ_POP_FRONT(BOOST_PP_SEQ_FOR_EACH(LOGARGS_PAIR, ~, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)))), __VA_ARGS__))

Even works with vectors:

int64_t x = -1234;
unsigned volume = 10;
double pi = 3.1415926535;
const char* name = "test";
std::string str = "hello";
auto coords = std::vector{15, 8, 128};

LOGARGS(x, volume, pi, name, str, coords);

prints this:

x:-1234, volume:10, pi:3.1415926535, name:test, str:hello, coords:[15, 8, 128]

Note, that it all expands to my own LOG macro that works as puts call with a single std::string_view argument.

The problem with this solution is that it uses boost::preprocessor and I assume this thing slows down compilation (I haven't verified it). It also uses std::format, that's why vectors and some std containers could be printed without any work.

Overall, it takes variadic args, converts it to sequence, then for each element it converts them using LOGARGS_PAIR to the following seqeuence:

LOGARGS_PAIR(x) LOGARGS_PAIR(volume) ...

LOGARGS_PAIR converts to:

(", ")("x" ":{}") (", ")("volume" ":{}") ...

Then, I remove first element from the sequence using BOOST_PP_SEQ_POP_FRONT and flatten it using BOOST_PP_SEQ_CAT. This creates format string for std::format:

"x" ":{}" ", " "volume" ":{}" ...

Collectives™ on Stack Overflow

LOG macro that logs named variables

3 Answers 3

9 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

9 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related