Here’s a rewritten version of your question:

“I’m trying to create a std::print() wrapper that modifies the output format, such as adding a prefix and suffix around the original format. I was able to achieve this using a macro. How can I improve this approach or implement it differently for more flexibility?”

#define DECORATED_PRINT(fmt, ...) std::println("prefix " fmt " suffix", __VA_ARGS__)

To achieve a std::print() wrapper with a modified format (e.g., adding a prefix and suffix), using a macro is one way, but there are other approaches that might offer more flexibility and better maintainability. Here are a few options:

1. Using a Macro

You can use a macro to wrap std::print() and modify the format. Here’s a simple example:

#define PRINT_WITH_FORMAT(fmt, ...) std::print("[Prefix] " fmt " [Suffix]\n", ##__VA_ARGS__)

While this works, macros have limitations in terms of type safety, debugging, and maintainability, especially for larger projects.

2. Using a Function Template

For more flexibility, you can create a function template that wraps std::print() and modifies the format. This way, you avoid the pitfalls of macros while still achieving the same goal:

#include <format>
#include <iostream>

template<typename... Args>
void print_with_format(const std::string& fmt, Args&&... args) {
    std::string formatted_message = std::format("[Prefix] " + fmt + " [Suffix]\n", std::forward<Args>(args)...);
    std::cout << formatted_message;
}

Usage:

print_with_format("Hello, {}!", "World");

3. Custom Formatter (Advanced)

If you want more control over the formatting process, you can create a custom formatter by extending std::formatter:

#include <format>
#include <iostream>

template <>
struct std::formatter<std::string> {
    constexpr auto parse(auto& ctx) {
        return ctx.begin();
    }

    auto format(const std::string& s, auto& ctx) {
        return std::format_to(ctx.out(), "[Prefix] {} [Suffix]", s);
    }
};

void print_with_format(const std::string& message) {
    std::cout << std::format("{}", message) << '\n';
}

This approach gives you deep customization over how different types are formatted.

Conclusion

• Macros are quick and simple but have limitations in flexibility and maintainability.
• Function templates offer a more modern, type-safe, and maintainable solution.
• Custom formatters provide advanced control and customization, especially for complex formatting needs.

For most use cases, the function template approach strikes a good balance between flexibility and simplicity.