std::format

std::format (заголовок <format>) — функция форматирования строк с плейсхолдерами {}, заменяемыми аргументами по порядку, либо по явному индексу {0}/{1} (что позволяет переставлять порядок вывода без изменения порядка аргументов вызова). После двоеточия внутри плейсхолдера идёт спецификатор формата: {:.2f} — 2 знака после запятой, {:>10} — выравнивание по правому краю в поле шириной 10 символов, {:x} — шестнадцатеричное представление. Функция возвращает std::string, ничего не печатая напрямую.std::format (from <format>) is a string-formatting function with {} placeholders substituted by arguments in order, or by an explicit index {0}/{1} (which lets you reorder the output without changing the call's argument order). After a colon inside a placeholder comes a format specifier: {:.2f} — 2 digits after the decimal point, {:>10} — right-aligned in a 10-character field, {:x} — hexadecimal. The function returns a std::string, printing nothing directly.

char buf[64];
snprintf(buf, sizeof(buf), "%s is %d years old", name.c_str(), age);
// name должен быть вручную сконвертирован в C-строку;// name must be manually converted to a C string;
// %d для double — UB в рантайме, компилятор может не поймать// %d for a double — runtime UB, the compiler may not catch it

std::ostringstream oss;
oss << name << " is " << std::setprecision(2) << age << " years old";
// типобезопасно, но многословно, манипуляторы стекируются и// type-safe, but verbose — manipulators stack up and
// не дают декларативно переставить позицию аргумента// don't let you declaratively reorder an argument's position

auto msg = std::format("{} is {} years old", name, age);
// типобезопасно: name — напрямую std::string, без .c_str()// type-safe: name is a std::string directly, no .c_str()

auto swapped = std::format("{1} {0}", "world", "hello");
// "hello world" — позиция вывода задана индексом, без// "hello world" — output position set by index, without
// изменения порядка аргументов вызова// changing the call's argument order

auto price = std::format("{:>10.2f}", 3.14159);
// "      3.14" — 2 знака после запятой, ширина поля 10, вправо// "      3.14" — 2 decimal digits, field width 10, right-aligned

Ни один из двух существовавших подходов к форматированию строк не был одновременно типобезопасным, удобным и производительным:Neither of the two existing approaches to string formatting was simultaneously type-safe, convenient, and fast:

std::format — не изобретение с нуля, а стандартизация сторонней библиотеки {fmt} (Victor Zverovich), которая годами использовалась в продакшене как раз ради решения этой проблемы — та же история, что и у boost::filesystem, ставшего прототипом std::filesystem.std::format isn't invented from scratch — it standardizes the third-party {fmt} library (Victor Zverovich), which had already been used in production for years to solve exactly this problem — the same story as boost::filesystem becoming the prototype for std::filesystem.

Строка формата разбирается на этапе компиляции, если она передана как constexpr-значение (обычный строковый литерал квалифицируется автоматически) — компилятор проверяет число плейсхолдеров и типы аргументов относительно спецификаторов формата ещё до генерации кода. Каждый тип аргумента находит свою реализацию через специализацию шаблона std::formatter<T>, которую можно определить и для собственных типов.The format string is parsed at compile time when it's passed as a constexpr value (an ordinary string literal qualifies automatically) — the compiler checks the placeholder count and argument types against the format specifiers before any code is even generated. Each argument type finds its implementation through a std::formatter<T> template specialization, which can also be defined for user-defined types.

#include <format>

struct Point { int x, y; };

// специализация formatter для собственного типа// a formatter specialization for a user-defined type
template <>
struct std::formatter<Point> : std::formatter<std::string> {
    auto format(const Point& p, auto& ctx) const {
        return std::formatter<std::string>::format(
            std::format("({}, {})", p.x, p.y), ctx);
    }
};

std::string s = std::format("point = {}", Point{1, 2});
// "point = (1, 2)" — без ручной конвертации в C-строку// "point = (1, 2)" — no manual conversion to a C string

auto hex = std::format("{:x}", 255);   // "ff"// "ff"

Если строка формата — не compile-time константа (например, получена в рантайме из конфигурации или пользовательского ввода), std::format в такой вызов не компилируется — для этого случая есть отдельная функция std::vformat, принимающая уже упакованные аргументы через std::make_format_args.If the format string isn't a compile-time constant (say, it comes from configuration or user input at runtime), that call to std::format simply won't compile — for this case there's a separate function, std::vformat, which takes pre-packed arguments via std::make_format_args.

Специализация выше наследуется от std::formatter<std::string> ради краткости, но полноценный кастомный форматтер пишется как отдельная пара методов parse()/format() — parse() разбирает часть спецификатора после двоеточия (например, свои флаги вроде {:short}) и возвращает итератор на позицию, где разбор остановился, а format() пишет результат в выходной итератор контекста. Минимальный скелет, не поддерживающий собственных флагов, просто пропускает разбор спецификатора насквозь:The specialization above inherits from std::formatter<std::string> for brevity, but a full custom formatter is written as a separate pair of methods, parse()/format() — parse() parses the part of the specifier after the colon (say, your own flags like {:short}) and returns an iterator to where parsing stopped, while format() writes the result into the context's output iterator. A minimal skeleton that supports no flags of its own just passes the specifier parsing straight through:

struct Money { long long cents; };

template <>
struct std::formatter<Money> {
    // парсинг спецификатора формата — здесь без своих флагов,// format-specifier parsing — no custom flags here,
    // просто находим позицию закрывающей '}' и останавливаемся на ней// just find the closing '}' and stop right there
    constexpr auto parse(std::format_parse_context& ctx) {
        return ctx.begin();
    }

    // собственно форматирование — пишем в ctx.out(), возвращаем итератор// the actual formatting — write into ctx.out(), return the iterator
    auto format(const Money& m, std::format_context& ctx) const {
        return std::format_to(ctx.out(), "${}.{:02}", m.cents / 100, m.cents % 100);
    }
};

std::string s = std::format("total: {}", Money{4250});  // "total: $42.50"// "total: $42.50"

• cppreference — std::format
• WG21 P0645 — Text Formatting
• fmt.dev — the {fmt} library (prototype for std::format)