How do I efficiently forward the formatting arguments when implementing a formatter for a custom type

Question

I am trying to write a custom formatter to help me print vectors. I am attempting to maintain the format specifiers so that each item in the vector is formatted the same way.

I have taken most of my inspiration from this tutorial, and the docs

#include <fmt/core.h>
#include <fmt/format.h>

template<typename ValueType>
struct fmt::formatter<std::vector<ValueType>> : fmt::formatter<ValueType>
{
    std::string formatString;

    // Hack, copy the original format text into a std::string
    constexpr auto parse(format_parse_context& ctx)
    {
        formatString= "{:";
        for (auto iter = std::begin(ctx); iter  != std::end(ctx); ++iter) {
            char c = *iter;{
                formatString += c;
            }
            if (c == '}') {
                return iter;
            }
        }
        return std::end(ctx);
    }

    template <typename FormatContext>
    auto format(const std::vector<ValueType>& container, FormatContext& context)
    {
        auto&& out = context.out();
        format_to(out, "{{");

        typename std::vector<ValueType>::size_type count = 0;
        const typename std::vector<ValueType>::size_type size = container.size();
        for (const auto& item : container) {
            // Use the copied format string, but really want to delegate the formatting to superclass...
            format_to(out, formatString, item);
            if (++count < size) {
                format_to(out, ", ");
            }
        }

        return format_to(out, "}}");
    }
};

int main()
{
    fmt::print("{:.3f}\n", std::vector{ 0.0, 321.123, 654398.4328, -0.0000000000012345, 2374651273.7236457862345});
    fmt::print("{:.1e}\n", std::vector{ 0.0, 321.123, 654398.4328, -0.0000000000012345, 2374651273.7236457862345});
    return 0;
}

Which outputs:

{0.000, 321.123, 654398.433, -0.000, 2374651273.724}
{0.0e+00, 3.2e+02, 6.5e+05, -1.2e-12, 2.4e+09}

It seems overly clunky and inefficient to copy the format string just so I can feed it back into another fmt::format call, especially when the extended class : fmt::formatter<ValueType> is already providing us with a perfectly valid parse function internally, (which I have re-implemented in this example just to get the desired output in a hacky way).

I really want to remove the custom parse implementation and replace the line

format_to(out, formatString, item);

with

format_to(out, fmt::formatter<ValueType>::format(item, context))

except it isn't valid/doesn't compile.

What is the correct way to do this?

---

Note: I am completely aware of the pointlessness of extending the type in my example, and that I could have it as a local variable however I am trying to reuse the functionality of the class, so extending it feels like the right direction, even if I haven't found the solution yet.

---

A list of all the other examples I have found which haven't helped me yet:

• String formatting the cool way with C++20 std::format() (only works for directly returning a single call to the super implementation, but it doesn't require re-implementing parse or creating a new format string)
• Custom format specifier with {fmt} for custom class (Discards formatting or requires manual re-implementation of formatting)
• The tutorial I mostly copied (Almost what I want, but still creating a new format string instead of reusing the one originally specified by the user)
• The Docs (Again, either suggests re-implementing the parse function and recalling format with a new format string, despite the caller having already specified one and there being an existing parse function for the type...)

Answer 1

You can get rid of your parse implementation and use the inherited function, and use fmt::formatter<ValueType>::format(item, context) inside your format to output each item (godbolt demo):

#include <fmt/core.h>
#include <fmt/format.h>

template<typename ValueType>
struct fmt::formatter<std::vector<ValueType>> : fmt::formatter<ValueType>
{
    template <typename FormatContext>
    auto format(const std::vector<ValueType>& container, FormatContext& context)
    {
        auto&& out = context.out();
        format_to(out, "{{");

        bool first = true;
        for (const auto& item : container) {
            if (first) {
                first = false;
            } else {
                format_to(out, ", ");
            }
            fmt::formatter<ValueType>::format(item, context);
        }

        return format_to(out, "}}");
    }
};

int main()
{
    fmt::print("{:.3f}\n", std::vector{ 0.0, 321.123, 654398.4328, -0.0000000000012345, 2374651273.7236457862345});
    fmt::print("{:.1e}\n", std::vector{ 0.0, 321.123, 654398.4328, -0.0000000000012345, 2374651273.7236457862345});
    return 0;
}

---

You can see other examples of this pattern in the docs under Formatting User-defined Types.