Форматирование текста — одна из самых распространённых задач, с которыми сталкивается каждый разработчик. За долгую историю C++ было создано несколько подходов к решению этой казалось бы тривиальной проблемы, но, как часто бывает в мире программирования, у каждого из них обнаружились свои недостатки. Всё начиналось с печально известного семейства функций printf, унаследованных из языка C. Помню свой первый крупный проект на C++ — я тогда потратил почти три дня на отлов бага, связанного с неправильным форматированием. Код выглядел примерно так:
| C++ | 1
| printf("Value of counter: %f", counter); |
|
counter имел тип int, что привело к непредсказуемому поведению программы. Классика жанра! В этом главный недостаток printf — отсутствие какой-либо проверки типов на этапе компиляции. С появлением стандартной библиотеки C++ разработчики получили iostream с его потоковыми операторами << и >>. Этот подход решил проблему типобезопасности, но создал новые трудности:
| C++ | 1
| std::cout << "Координаты: (" << x << ", " << y << ")" << std::endl; |
|
| C++ | 1
| std::cout << "Баланс: " << std::fixed << std::setprecision(2) << balance << " руб." << std::endl; |
|
<iomanip>, иначе компилятор не найдёт std::setprecision. И да, эфект от манипуляторов сохраняется до конца срока жизни потока, что может привести к непредвиденному форматированию последующих значений — класическая ловушка для начинающих.
Некоторые разработчики пытались решить проблему с помощью std::stringstream, что давало больше контроля, но приводило к ещё более многословному коду:
| C++ | 1
2
3
| std::stringstream ss;
ss << std::fixed << std::setprecision(2) << "Баланс: " << balance << " руб.";
std::string result = ss.str(); |
|
Столкнувшись с этими ограничениями, комьюнити C++ начало искать альтернативы. Первой значимой попыткой стала библиотека boost::format, которая предложила синтаксис, напоминающий printf, но с типобезопасностью:
| C++ | 1
| std::string result = boost::str(boost::format("Баланс: %.2f руб.") % balance); |
|
boost::format была шагом в правильном направлении, но имела свои проблемы: зависимость от Boost (что не всегда приемлемо), относительно низкая производительность и не самый интуитивный API для сложных случаев форматирования. Настоящим прорывом стала библиотека {fmt} (ранее известная как cppformat), созданая Виктором Зверовичем. Она предложила элегантный, типобезопасный и производительный способ форматирования:
| C++ | 1
| std::string result = fmt::format("Баланс: {:.2f} руб.", balance); |
|
{fmt} так удачно решала проблемы форматирования, что стала основой для стандартного std::format в C++20. Она сочетает лучшее из обоих миров: типобезопасность C++ с лаконичностью Python-подобного синтаксиса форматирования. Стоит отметить, что потребность в улучшении механизмов форматирования была настолько острой, что многие команды разработчиков создавали собственные решения. Я неоднократно сталкивался с проектами, где были реализованы самописные системы форматирования — от простых оберток вокруг snprintf до сложных темплейтных конструкций. Такой подход только усложнял понимание кодовой базы и повышал вероятность ошибок. В конечном итоге комитет по стандартизации C++ понял необходимость стандартизации современного, типобезопасного и удобного механизма форматирования, что привело к появлению std::format в C++20 — пожалуй, одного из самых важных дополнений к языку за последнее десятилетие.
Фундамент std::format
Когда я впервые столкнулся со std::format, меня буквально накрыло волной облегчения — наконец-то в C++ появился современный, элегантный и безопасный способ форматирования текста. Сегодня сложно представить, как мы годами мирились с неуклюжими конструкциями, когда можно было иметь такой лаконичный и мощный инструмент.
Синтаксис, который не хочется забыть
Базовая концепция std::format обманчиво проста: функция принимает строку формата и произвольное количество аргументов, которые подставляются в эту строку. Места для подстановки обозначаются фигурными скобками:
| C++ | 1
| std::string result = std::format("Привет, {}! Тебе сегодня {} лет.", имя, возраст); |
|
printf, но без спецификаторов типа %d или %s. И это не просто косметическое изменение, а фундаментальный сдвиг парадигмы — теперь мы можем не беспокоиться о соответствии спецификаторов типам передаваемых аргументов.
Одним из важнейших преимуществ std::format перед предшественниками является его интуитивно понятный синтаксис. Внутри фигурных скобок можно указывать не только позицию аргумента, но и детальные инструкции форматирования:
| C++ | 1
2
3
4
5
6
7
| // Форматирование числа с плавающей точкой
std::format("Число π примерно равно {:.5f}", 3.14159265359);
// Вывод: "Число π примерно равно 3.14159"
// Управление шириной поля и выравниванием
std::format("│{:^15}│{:^15}│", "Имя", "Оценка");
// Вывод: "│ Имя │ Оценка │" |
|
| C++ | 1
2
| std::string msg = std::format("{0} имеет {1} яблок, а {2} — {3}. {0} отдаёт {2} одно яблоко, теперь у {0} {1} яблок, а у {2} — {3}.",
"Алиса", 5, "Боб", 3); |
|
printf или iostream — получите нечитаемую кашу из повторений.
Типобезопасность без компромиссов
Главное, за что все так полюбили std::format — типобезопасность. Ошибки времени выполнения, связаные с неправильным сопоставлением форматных спецификаторов и типов аргументов, ушли в прошлое.
Компилятор теперь проверяет совместимость аргументов и спецификаторов формата, выдавая понятные ошибки на этапе компиляции:
| C++ | 1
2
| std::format("{:d}", "строка"); // Ошибка компиляции! Нельзя форматировать строку как целое число
std::format("{:s}", 42); // Ошибка компиляции! Нельзя форматировать число как строку |
|
printf с неправильными спецификаторами просто выдаст мусор или, что еще хуже, приведет к неопределённому поведению. Излюбленная мишень для ошибок безопасности, которую наконец-то устранили. Другой мощный аспект std::format — это возможность расширения на пользовательские типы. В отличие от printf, который работает только с фиксированным набором встроенных типов, или iostream, требующего перегрузки operator<<, для std::format можно определить специализацию std::formatter для своего типа:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| struct Point {
double x, y;
};
template <>
struct std::formatter<Point> {
constexpr auto parse(format_parse_context& ctx) {
return ctx.begin();
}
auto format(const Point& p, format_context& ctx) const {
return format_to(ctx.out(), "({:.2f}, {:.2f})", p.x, p.y);
}
};
// Теперь можно использовать Point с std::format
Point p{1.234, 5.678};
std::format("Координаты точки: {}", p); // Вывод: "Координаты точки: (1.23, 5.68)" |
|
Под капотом
Когда компилятор встречает вызов std::format, происходит настоящее волшебство. Во время компиляции разбирается строка формата, проверяется корректность спецификаторов и их соответствие типам аргументов. Эта информация используется для генерации эффективного кода, который выполнит форматирование во время работы программы. Строка формата разбирается на обычные фрагменты текста и подстановочные выражения вида {<index>:<format>}, где:
<index> — опциональный индекс аргумента (начиная с 0).
<format> — опциональный спецификатор формата.
Если индекс не указан, то аргументы используются последовательно:
| C++ | 1
| std::format("{} + {} = {}", 2, 2, 4); // Эквивалентно std::format("{0} + {1} = {2}", 2, 2, 4) |
|
formatter, который выполняет собственно преобразование значения аргумента в строковое представление согласно спецификатору формата.
Форматирование в сравнении с прошлым
Сравним фрагменты кода для вывода таблицы с данными, используя различные методы форматирования:
С использованием printf:
| C++ | 1
2
3
| printf("│%-15s│%15.2f│\n", "Процессор", 349.99);
printf("│%-15s│%15.2f│\n", "Материнская плата", 145.50);
printf("│%-15s│%15.2f│\n", "Память", 89.99); |
|
iostream:
| C++ | 1
2
3
4
5
6
| std::cout << "│" << std::left << std::setw(15) << "Процессор"
<< "│" << std::right << std::setw(15) << std::fixed << std::setprecision(2) << 349.99 << "│" << std::endl;
std::cout << "│" << std::left << std::setw(15) << "Материнская плата"
<< "│" << std::right << std::setw(15) << 145.50 << "│" << std::endl;
std::cout << "│" << std::left << std::setw(15) << "Память"
<< "│" << std::right << std::setw(15) << 89.99 << "│" << std::endl; |
|
std::format:
| C++ | 1
2
3
| std::cout << std::format("│{:<15}│{:>15.2f}│\n", "Процессор", 349.99);
std::cout << std::format("│{:<15}│{:>15.2f}│\n", "Материнская плата", 145.50);
std::cout << std::format("│{:<15}│{:>15.2f}│\n", "Память", 89.99); |
|
std::format очевидно: код компактен, легко читается и при этом сохраняет все возможности форматирования. И самое главное — производительность! Вопреки распространенному мнению, что удобство всегда приходит за счёт скорости, std::format часто работает быстрее, чем альтернативы, благодаря возможностям компиляционной оптимизации и эфективной реализации.
Важно отметить ещё одну выдающуюся особенность std::format — бескомпромиссная обработка исключений при некорректном форматировании. В отличие от семейства функций printf, где ошибки тихо приводят к непредсказуемому поведению, std::format выбрасывает исключения типа std::format_error, когда сталкивается с неправильным синтаксисом в строке формата:
| C++ | 1
2
3
4
5
| try {
auto s = std::format("{0} и {}", "Алиса", "Боб"); // Ошибка! Смешивание индексированных и автоматических позиций
} catch (const std::format_error& e) {
std::cerr << "Ошибка форматирования: " << e.what() << std::endl;
} |
|
std::format невероятно гибкие. Они позволяют контролировать практически любой аспект вывода:
| C++ | 1
2
3
4
5
6
7
8
9
10
| // Форматирование целых чисел
std::format("{:x}", 255); // "ff" (шестнадцатеричное представление)
std::format("{:#x}", 255); // "0xff" (с префиксом)
std::format("{:o}", 255); // "377" (восьмеричное представление)
std::format("{:b}", 255); // "11111111" (двоичное представление)
// Форматирование чисел с плавающей точкой
std::format("{:e}", 1000000.0); // "1.000000e+06" (экспоненциальная форма)
std::format("{:.2f}", 3.14159); // "3.14" (фиксированная точность)
std::format("{:g}", 0.000001); // "1e-06" (общий формат) |
|
std::format также элегантно решает проблему локализации чисел. Например, в некоторых языках принято использовать запятую вместо точки в качестве разделителя:
| C++ | 1
2
| // Использование локализации
std::format(std::locale("ru_RU.UTF-8"), "{:L}", 1234.56); // "1 234,56" (с русской локалью) |
|
std::format стал незаменимым при разработке мультиязычных интерфейсов — больше никаких хаков с sprintf и кастомных функций для локализованого форматирования!
Std::vector<std::pair<std::vector<int>::iterator, std::vector<int>::iterator>
Вопрос по вектору.
Допустим есть вектор,
std::vector<int> vec;
на каком - то этапе заполнения я... ошибка error: cannot convert 'std::string {aka std::basic_string<char>}' to 'std::string* {aka std::basic_stri
на вод поступают 2 строки типа string. определить количество вхождений строки 2 в строку 1
ошибка... Clang-format конфигурация стиля с использованием .clang-format
Добрый день!
Никак не могу сконфигурировать файл .clang-format. Мне необходимо чтобы при... STL std::set, std::pair, std::make_pair
Я не знаю как описать тему в двух словах, поэтому не обращайте внимание на название темы....
Практическое применение
Форматирование сложных структур данных
Одна из самых трудоёмких задач — вывод содержимого контейнеров. С появлением std::format эта проблема решается элегантно и лаконично. Взгляните на пример форматирования вектора:
| C++ | 1
2
3
4
| std::vector<int> numbers = {1, 2, 3, 4, 5};
std::string result = std::format("Числа: [{}]",
fmt::join(numbers, ", "));
// Вывод: "Числа: [1, 2, 3, 4, 5]" |
|
fmt::join — небольшой хак, поскольку стандартная библиотека пока не предоставляет аналогичную функцию. К сожалению, в C++20 стандартизировали только базовую функциональность форматирования, а многие удобные утилиты из библиотеки {fmt} придётся ждать в будущих стандартах.
Для вложенных контейнеров задача усложняется, но всё равно решается гораздо чище, чем при использовании потоков:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
| std::map<std::string, std::vector<int>> data = {
{"Алиса", {90, 85, 95}},
{"Боб", {80, 70, 75}}
};
std::string report;
for (const auto& [name, scores] : data) {
report += std::format("{}: {}\n", name,
fmt::join(scores, ", "));
}
// Вывод:
// Алиса: 90, 85, 95
// Боб: 80, 70, 75 |
|
std::map, но это уже тема для следующей главы.
Хитрости с позиционными аргументами
Позиционные аргументы — недооценённая возможность std::format, которая может существенно упростить сложную логику форматирования, особенно в специализированных контекстах, таких как логирование или интернационализация. Например, при работе с локализациями разных языков, порядок слов в предложении может отличаться:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
| // Английский
std::format("{0} has {1} apples", "Alice", 5);
// "Alice has 5 apples"
// Русский (для иллюстрации порядка аргументов)
std::format("У {0} есть {1} яблок", "Алисы", 5);
// "У Алисы есть 5 яблок"
// Японский (гипотетический пример, где порядок существенно иной)
std::format("{1}つのリンゴが{0}にあります", "アリス", 5);
// "5つのリンゴがアリスにあります" (5 яблок у Алисы есть) |
|
| C++ | 1
2
3
| // Повторение аргументов
std::format("Имя: {0}, Возраст: {1}, Контакт: {0}", "Иван", 30);
// "Имя: Иван, Возраст: 30, Контакт: Иван" |
|
Продвинутое форматирование чисел
В работе с финансовыми данными или научными вычислениями правильное отображение чисел критически важно. std::format предоставляет богатый набор возможностей:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| double pi = 3.14159265358979323846;
// Управление точностью
std::format("{:.10f}", pi); // "3.1415926536"
// Научная нотация
std::format("{:e}", pi); // "3.141593e+00"
std::format("{:.10e}", pi); // "3.1415926536e+00"
// Автоматический выбор лучшего представления
std::format("{:g}", pi); // "3.14159"
std::format("{:.10g}", pi); // "3.141592654"
// Шестнадцатеричное представление чисел с плавающей точкой (C++23)
// std::format("{:a}", pi); // "0x1.921fb54442d18p+1" |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
| double amount = 1234567.89;
// Форматирование валюты
std::format("{:L}", amount); // Зависит от текущей локали
std::format(std::locale("en_US.UTF-8"), "{:L}", amount); // "1,234,567.89"
std::format(std::locale("de_DE.UTF-8"), "{:L}", amount); // "1.234.567,89"
// С символом валюты (на примере fmt, будет в C++23)
// fmt::format(std::locale("en_US.UTF-8"), "{:L¤}", amount); // "$1,234,567.89"
// fmt::format(std::locale("de_DE.UTF-8"), "{:L¤}", amount); // "1.234.567,89 €" |
|
std::format в C++20 не имеет встроенной поддержки манипулирования локалями для чисел — это доступно только в std::format с C++23. В C++20 нужно использовать либо библиотеку {fmt}, либо создавать собственные решения.
Форматирование времени и даты
Одной из больших проблем в C++ всегда было форматирование даты и времени. До появления std::format и стандартной бибиотеки <chrono> это было настоящей головной болью:
| C++ | 1
2
3
4
5
| // Старый подход с использованием C API
std::time_t t = std::time(nullptr);
char buffer[80];
std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", std::localtime(&t));
std::string timestamp(buffer); |
|
std::format и <chrono> в C++20 это становится намного проще и безопаснее:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
| auto now = std::chrono::system_clock::now();
auto today = std::chrono::year_month_day{
std::chrono::floor<std::chrono::days>(now)};
// К сожалению, напрямую chrono::formatter есть только в C++23
// std::format("{:%Y-%m-%d}", today); // "2023-10-20"
// Но можно использовать std::format с преобразованием в std::tm
auto time_t = std::chrono::system_clock::to_time_t(now);
auto local_time = *std::localtime(&time_t);
std::format("{:%Y-%m-%d %H:%M:%S}", local_time); // "2023-10-20 15:30:45" |
|
<chrono> напрямую не поддерживается стандартной библиотекой, эта функциональность появляется только в C++23. Но даже с текущими возможностями мы получаем более чистый и типобезопасный код по сравнению с предыдущими подходами.
Форматирование текста с выравниванием и заполнением
Форматирование текстовых таблиц — это еще один классический случай, где std::format сияет:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
| // Заголовок таблицы с выравниванием и рамками
std::cout << std::format("┌{0:─^20}┬{0:─^10}┬{0:─^8}┐", "") << std::endl;
std::cout << std::format("│{:^20}│{:^10}│{:^8}│", "Наименование", "Цена", "Кол-во") << std::endl;
std::cout << std::format("├{0:─^20}┼{0:─^10}┼{0:─^8}┤", "") << std::endl;
// Строки таблицы с разным выравниванием
std::cout << std::format("│{:<20}│{:>10.2f}│{:^8}│", "Процессор Intel i7", 349.99, 1) << std::endl;
std::cout << std::format("│{:<20}│{:>10.2f}│{:^8}│", "ОЗУ 16 ГБ", 89.99, 2) << std::endl;
std::cout << std::format("│{:<20}│{:>10.2f}│{:^8}│", "SSD 1 TB", 129.99, 1) << std::endl;
// Нижняя граница таблицы
std::cout << std::format("└{0:─^20}┴{0:─^10}┴{0:─^8}┘", "") << std::endl; |
|
| C++ | 1
2
3
4
5
6
7
| ┌────────────────────┬──────────┬────────┐
│ Наименование │ Цена │ Кол-во │
├────────────────────┼──────────┼────────┤
│Процессор Intel i7 │ 349.99│ 1 │
│ОЗУ 16 ГБ │ 89.99│ 2 │
│SSD 1 TB │ 129.99│ 1 │
└────────────────────┴──────────┴────────┘ |
|
- Выравнивание (
< — по левой стороне, > — по правой, ^ — по центру).
- Ширину поля (число после двоеточия).
- Символ заполнения (одиночный символ перед выравниванием).
- Точность для чисел с плавающей точкой (
.N, где N — число знаков после запятой).
В приведённом примере я использовал символы псевдографики для рамок таблицы. Спецификатор {0:─^20} создаёт строку из 20 символов "─", центированную по ширине поля. Это нулевой аргумент — пустая строка "", поэтому выводятся только символы заполнения. Отступы и выравнивание также крайне полезны при создании логов или вывода отладочной информации с ровными колонками:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Форматирование лога
auto log_entry = [](const std::string& level, const std::string& module, const std::string& message) {
auto now = std::chrono::system_clock::now();
auto time_t = std::chrono::system_clock::to_time_t(now);
auto local_time = *std::localtime(&time_t);
return std::format("[{:%Y-%m-%d %H:%M:%S}] [{:^8}] [{:<15}] {}",
local_time, level, module, message);
};
std::cout << log_entry("INFO", "Network", "Connection established") << std::endl;
std::cout << log_entry("WARNING", "Auth", "Too many failed attempts") << std::endl;
std::cout << log_entry("ERROR", "FileSystem", "Cannot open file") << std::endl; |
|
| C++ | 1
2
3
| [2023-10-20 15:45:23] [ INFO ] [Network ] Connection established
[2023-10-20 15:45:24] [WARNING ] [Auth ] Too many failed attempts
[2023-10-20 15:45:25] [ ERROR ] [FileSystem ] Cannot open file |
|
Форматирование пользовательских типов
Одно из моих любимых преимуществ std::format — это лёгкость расширения на свои типы данных. В реальных проектах мы редко работаем только со встроенными типами, поэтому крайне важно иметь возможность красиво форматировать собственные классы. Вот простой пример форматирования пользовательского типа Person:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| struct Person {
std::string first_name;
std::string last_name;
int age;
};
template <>
struct std::formatter<Person> {
constexpr auto parse(std::format_parse_context& ctx) {
// Просто возвращаем итератор на конец диапазона
return ctx.begin();
}
auto format(const Person& p, std::format_context& ctx) const {
return std::format_to(ctx.out(), "{} {}, возраст: {}",
p.first_name, p.last_name, p.age);
}
};
Person alice{"Алиса", "Петрова", 28};
std::cout << std::format("Сотрудник: {}", alice) << std::endl;
// Вывод: "Сотрудник: Алиса Петрова, возраст: 28" |
|
Эффективная обработка ввода-вывода
Хотя многие примеры показывают использование std::format с std::cout, в реальных проектах особенно важна производительность при работе с потоками и файлами. Для этих случаев полезны функции std::format_to и std::format_to_n:
| C++ | 1
2
3
4
5
6
7
8
| std::vector<char> buffer(100);
auto result = std::format_to(buffer.begin(), "Число π: {:.5f}", 3.14159);
// buffer теперь содержит "Число π: 3.14159"
// result указывает на позицию после записи
// Альтернативно, чтобы ограничить запись первыми N символами:
auto [out, size] = std::format_to_n(buffer.begin(), 10, "Число π: {:.5f}", 3.14159);
// Запишет только первые 10 символов, size содержит общее требуемое количество символов |
|
Для самых критичных к производительности систем стоит рассмотреть возможность использования систем буферов с пулом памяти:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // Упрощенный пример структуры с пулом буферов
class LogBufferPool {
std::array<std::vector<char>, 16> buffers;
std::atomic<size_t> next_buffer{0};
public:
LogBufferPool() {
for (auto& buffer : buffers) {
buffer.resize(4096); // 4KB на буфер
}
}
std::vector<char>& get_buffer() {
return buffers[next_buffer++ % buffers.size()];
}
}; |
|
Расширенные возможности
Создание собственных форматтеров
После того как я освоил базовые возможности std::format, передо мной встал следующий вопрос: как адаптировать эту систему под специфические требования проекта? Ответ — создание пользовательских форматтеров. Эта возможность std::format позволяет глубоко интегрировать библиотеку с вашей кодовой базой.
Давайте рассмотрим более сложный пример, чем то что я показывал ранее — форматтер для собственного типа Color, который позволит выводить цвета в различных представлениях:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
| struct Color {
uint8_t r, g, b, a;
};
template <>
struct std::formatter<Color> {
enum class FormatType { RGB, HEX, HSL };
FormatType type = FormatType::RGB;
constexpr auto parse(std::format_parse_context& ctx) {
auto it = ctx.begin();
if (it != ctx.end() && *it != '}') {
switch (*it) {
case 'x': type = FormatType::HEX; break;
case 'h': type = FormatType::HSL; break;
case 'r': type = FormatType::RGB; break;
default: throw std::format_error("Invalid format for Color");
}
++it;
}
return it;
}
auto format(const Color& c, std::format_context& ctx) const {
switch (type) {
case FormatType::RGB:
return std::format_to(ctx.out(), "RGB({}, {}, {})", c.r, c.g, c.b);
case FormatType::HEX:
return std::format_to(ctx.out(), "#{:02x}{:02x}{:02x}", c.r, c.g, c.b);
case FormatType::HSL: {
// Упрощенная конвертация RGB -> HSL для демонстрации
float h = 0, s = 0, l = (c.r + c.g + c.b) / (3.0f * 255.0f);
return std::format_to(ctx.out(), "HSL({:.1f}, {:.1f}%, {:.1f}%)",
h, s * 100, l * 100);
}
}
return ctx.out(); // Никогда не вызывается, но избегает предупреждений компилятора
}
};
// Использование
Color purple{128, 0, 128, 255};
std::cout << std::format("Цвет в RGB: {}", purple) << std::endl;
std::cout << std::format("Цвет в HEX: {:x}", purple) << std::endl;
std::cout << std::format("Цвет в HSL: {:h}", purple) << std::endl; |
|
parse анализирует опции форматирования, указанные в строке формата, а метод format генерирует соответствующее представление. Ключевый момент здесь — гибкость: мы можем добавить любую логику форматирования, необходимую для наших бизнес-объектов.
Расширенное управление форматированием
Метод parse в форматтере играет критическую роль. Он получает контекст, содержащий оставшуюся часть спецификации формата, и возвращает итератор на символ после обработанной части. Это даёт нам возможность создавать по-настоящему сложные и гибкие форматтеры:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| template <>
struct std::formatter<Point3D> {
bool show_brackets = true;
char separator = ',';
int precision = 2;
constexpr auto parse(std::format_parse_context& ctx) {
auto it = ctx.begin();
if (it == ctx.end() || *it == '}') return it;
if (*it == 'n') { // no brackets
show_brackets = false;
++it;
}
if (it != ctx.end() && *it == ':') {
++it;
if (it != ctx.end()) {
separator = *it;
++it;
}
}
if (it != ctx.end() && *it == '.') {
++it;
precision = 0;
while (it != ctx.end() && std::isdigit(*it)) {
precision = precision * 10 + (*it - '0');
++it;
}
}
return it;
}
auto format(const Point3D& p, std::format_context& ctx) const {
std::string fmt_str = "{:." + std::to_string(precision) + "f}";
if (show_brackets) {
return std::format_to(ctx.out(), "({}{}{}{}{})",
std::format(fmt_str, p.x), separator,
std::format(fmt_str, p.y), separator,
std::format(fmt_str, p.z));
} else {
return std::format_to(ctx.out(), "{}{}{}{}{}",
std::format(fmt_str, p.x), separator,
std::format(fmt_str, p.y), separator,
std::format(fmt_str, p.z));
}
}
};
Point3D position{1.23456, -78.9, 0.0001};
std::cout << std::format("Обычное представление: {}", position) << std::endl;
std::cout << std::format("Без скобок: {:n}", position) << std::endl;
std::cout << std::format("С точкой с запятой: {:n;}", position) << std::endl;
std::cout << std::format("С 4 знаками после запятой: {:n;.4}", position) << std::endl; |
|
Производительность и оптимизации
Одна из сильных сторон std::format — баланс между удобством и производительностью. Однако в высоконагруженном коде можно дополнительно оптимизировать работу с форматированием. Для критичных к производительности участков кода std::format_to и std::format_to_n обеспечивают прямую запись в буферы без промежуточных аллокаций:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| // Предаллоцированный буфер для многократного использования
struct FormatBuffer {
std::array<char, 4096> buffer; // 4KB статический буфер
template <typename... Args>
std::string_view format(std::string_view fmt_str, Args&&... args) {
auto result = std::format_to(buffer.begin(), fmt_str, std::forward<Args>(args)...);
return std::string_view(buffer.data(), result - buffer.begin());
}
};
// Использование
FormatBuffer buf;
auto message = buf.format("Значение: {:.2f}, Статус: {}", 42.1234, "OK");
std::cout << message << std::endl; |
|
Форматирование в многопоточной среде
В современных приложениях многопоточность — скорее правило, чем исключение. При использовании std::format в многопоточной среде важно понимать аспекты потокобезопасности.
Сама функция std::format потокобезопасна в том смысле, что её можно вызывать одновременно из разных потоков без синхронизации. Однако при использовании разделяемых буферов или других общих ресурсов нужно быть осторожным:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| // Потокобезопасный форматтер логов
class ThreadSafeLogger {
std::mutex mutex;
std::ofstream log_file;
public:
ThreadSafeLogger(const std::string& filename) : log_file(filename, std::ios::app) {}
template <typename... Args>
void log(std::string_view fmt_str, Args&&... args) {
// Создаём строку локально в потоке
auto message = std::format(fmt_str, std::forward<Args>(args)...);
// Блокируем мьютекс только для записи в файл
std::lock_guard<std::mutex> lock(mutex);
log_file << message << std::endl;
}
};
// Использование
ThreadSafeLogger logger("application.log");
std::thread t1([&]() { logger.log("Поток 1: число = {}", 42); });
std::thread t2([&]() { logger.log("Поток 2: строка = {}", "test"); });
t1.join();
t2.join(); |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
| class LockFreeLogger {
struct LogEntry {
std::array<char, 1024> buffer;
std::atomic<bool> ready{false};
std::atomic<bool> processed{true};
};
std::array<LogEntry, 64> log_entries;
std::atomic<size_t> write_index{0};
std::jthread worker; // C++20 управляемый поток
std::atomic<bool> shutdown{false};
std::ofstream log_file;
public:
LockFreeLogger(const std::string& filename) : log_file(filename, std::ios::app) {
worker = std::jthread([this](std::stop_token stop_token) {
while (!stop_token.stop_requested() && !shutdown) {
process_logs();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
// Финальная обработка
process_logs();
});
}
~LockFreeLogger() {
shutdown = true;
// worker автоматически присоединится благодаря std::jthread
}
template <typename... Args>
bool log(std::string_view fmt_str, Args&&... args) {
// Находим свободную запись
for (size_t attempt = 0; attempt < log_entries.size(); ++attempt) {
size_t idx = (write_index.fetch_add(1, std::memory_order_relaxed) % log_entries.size());
auto& entry = log_entries[idx];
bool expected = true;
if (entry.processed.compare_exchange_strong(expected, false,
std::memory_order_acquire,
std::memory_order_relaxed)) {
// Нашли свободную запись
auto result = std::format_to_n(entry.buffer.begin(), entry.buffer.size() - 1,
fmt_str, std::forward<Args>(args)...);
*result.out = '\0'; // Null-терминатор для безопасности
entry.ready.store(true, std::memory_order_release);
return true;
}
}
return false; // Все записи заняты
}
private:
void process_logs() {
for (auto& entry : log_entries) {
bool expected = true;
if (entry.ready.compare_exchange_strong(expected, false,
std::memory_order_acquire,
std::memory_order_relaxed)) {
log_file << entry.buffer.data() << std::endl;
entry.processed.store(true, std::memory_order_release);
}
}
}
}; |
|
Интеграция с существующим кодом
Переход на std::format в больших проектах может быть постепенным. Часто нужно интегрировать новый подход с существующими системами логирования или форматирования. Вот как можно реализовать шаблонную обертку вокруг существующего логгера, чтобы добавить в него возможности std::format:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| template <typename Logger>
class FormatWrapper {
Logger& logger;
public:
explicit FormatWrapper(Logger& logger_instance) : logger(logger_instance) {}
template <typename... Args>
void info(std::string_view fmt_str, Args&&... args) {
logger.info(std::format(fmt_str, std::forward<Args>(args)...));
}
template <typename... Args>
void error(std::string_view fmt_str, Args&&... args) {
logger.error(std::format(fmt_str, std::forward<Args>(args)...));
}
};
// Использование с существующим логгером
LegacyLogger old_logger;
FormatWrapper wrapper(old_logger);
wrapper.info("Событие: {}, Статус: {}", "Login", "Success"); |
|
std::format без необходимости полностью переписывать существующий код.
Одним из моих любимых приемов является создание констант для частоиспользуемых форматов:
| C++ | 1
2
3
4
5
6
7
8
9
| namespace log_formats {
constexpr auto timestamp = "[{:%Y-%m-%d %H:%M:%S}] ";
constexpr auto user_action = "Пользователь {} выполнил действие {} ({})";
constexpr auto system_event = "Система: {}, Компонент: {}, Событие: {}";
}
// Использование
auto msg = std::format(log_formats::timestamp + log_formats::user_action,
now, "admin", "login", "web"); |
|
Сравнение с другими языками
Если взглянуть на другие современные языки, можно увидеть, откуда черпал вдохновение std::format. Python много лет имеет f-строки и метод .format(), C# предлагает строки интерполяции, а Rust имеет макрос format!.
Интересно сравнить эти подходы:
Python: f"Hello, {name}!" или "Hello, {}!".format(name)
C#: $"Hello, {name}!"
Rust: format!("Hello, {}!", name)
C++20: std::format("Hello, {}!", name)
Синтаксис C++ наиболее близок к Rust и Python, что неудивительно, учитывая ориентацию на производительность и гибкость. Однако C++ пока не имеет эквивалента f-строк Python или строк интерполяции C#, которые позволяют встраивать выражения прямо в строковые литералы. Есть информация, что в C++26 может появиться аналог f-строк, возможно, с синтаксисом f"Hello, {name}!". Это стало бы логичным продолжением развития форматирования в C++, и я, признаться, только приветствовал бы такое удобство.
Производительность и оптимизации
В вопросах производительности std::format показывает себя достойно. Современные реализации часто быстрее, чем sprintf и уж точно быстрее, чем комбинация std::ostringstream с манипуляторами. Тем не менее, есть еще возможности для оптимизации, особенно с использованием новых возможностей C++20, таких как концепты. Например, можно ожидать специализированных алгоритмов форматирования для различных категорий типов. Также стоит отметить, что компиляторы постоянно улучшают оптимизацию constexpr выражений. Если строка формата известна на этапе компиляции, теоретически большая часть обработки может быть выполнена компилятором, а не во время выполнения.
Интеграция с концептами и диапазонами
Интеграция std::format с другими новыми возможностями C++20 — еще одно перспективное направление. Концепты могут сделать создание пользовательских форматтеров более безопасным и выразительным, а диапазоны предоставят новые возможности для обработки коллекций. Представьте возможность форматировать только элементы диапазона, удовлетворяющие определенному критерию:
| C++ | 1
2
3
| // Гипотетический пример будущего синтаксиса
std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::print("Четные числа: {}", numbers | std::views::filter([](int n) { return n % 2 == 0; })); |
|
Реальные примеры внедрения std::format в проектах
Когда я впервые встретил std::format в C++20, сразу задумался о том, как это нововведение впишется в реальные боевые проекты.
Миграция системы логирования в финтех-проекте
В одном крупном финансовом приложении, над которым мне довелось работать, существовала разветвлённая система логирования, построенная на смеси printf-подобных функций и самописной обёртки над std::ostringstream. Когда мы решили мигрировать на C++20, первым кандидатом на модернизацию стала именно система логов. Старый код выглядел примерно так:
| C++ | 1
2
3
4
5
6
| // Кошмарно-многословный подход
logger::LogEvent event(LOG_LEVEL_INFO, "TransactionModule");
event << "Transaction " << txId << " processed: amount="
<< std::fixed << std::setprecision(2) << amount
<< ", currency=" << currency << ", status=" << statusToString(status);
logger::LogManager::getInstance().log(event); |
|
std::format позволило переписать это в более читаемую форму:
| C++ | 1
2
3
| // После миграции на std::format
logger.info("Transaction {} processed: amount={:.2f}, currency={}, status={}",
txId, amount, currency, statusToString(status)); |
|
Интернационализация игрового движка
Другой интересный случай касался небольшого инди-движка для игр. Система интернационализации представляла собой настоящий ад из sprintf и ручной подстановки переменных в разных языках:
| C++ | 1
2
3
4
5
| // До: кошмар интернационализации
const char* formatStr = localizeString("player_health");
char buffer[256];
sprintf(buffer, formatStr, playerName.c_str(), currentHealth, maxHealth);
ui->setText("healthLabel", buffer); |
|
Английский: "{0}'s health: {1}/{2}"
Немецкий: "Gesundheit von {0}: {1}/{2}"
Японский: "{1}/{2} - {0}のヘルス"
С std::format решение стало элегантным и безопасным:
| C++ | 1
2
3
| // После: красота и безопасность типов
std::string formatStr = localizeString("player_health");
ui->setText("healthLabel", std::format(formatStr, playerName, currentHealth, maxHealth)); |
|
std::format. Локализаторам больше не нужно было объяснять магию printf и почему порядок подстановок критичен! Число ошибок при локализации снизилось почти до нуля, а кол-во кода, отвечающего за форматирование строк, сократилось примерно на 40%.
Создание DSL для научной визуализации
Особено запомнился проект научной визуализации, где мы использовали std::format как основу для создания предметно-ориентированного языка (DSL). Идея была в том, чтобы позволить ученым, не являющимся профессиональными программистами, создавать визуализации данных с помощью декларативных описаний.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Фрагмент DSL на основе std::format
Plot plot = interpreter.parse(R"(
plot({data}, {
title: "Temperature Distribution",
x_label: "Time (ms)",
y_label: "Temperature (°C)",
style: {
line: "dashed",
color: "#{:02x}{:02x}{:02x}",
width: {:.1f}
}
})
)", r, g, b, lineWidth); |
|
std::format, что позволило создать гибкий и расширяемый синтаксис. Гениальность решения в том, что система типов C++ и безопасность std::format обеспечивали проверку типов выражений DSL на этапе компиляции – никаких неожиданных ошибок времени выполнения!
Уроки, извлеченные из миграции
На основе опыта внедрения std::format в различных проектах, я выделил несколько важных уроков:
1. Начинайте с логирования – это наименее рискованная область и даёт быстрые осязаемые результаты.
2. Пишите обертки для плавной миграции – нет необходимости переписывать весь код сразу:
| C++ | 1
2
3
4
5
6
7
8
9
10
| // Обёртка для плавной миграции
template<typename... Args>
std::string legacyFormat(const char* fmt, Args&&... args) {
// Для старого кода используем sprintf
if (isLegacyFormatString(fmt)) {
return sprintfWrapper(fmt, std::forward<Args>(args)...);
}
// Для нового кода используем std::format
return std::format(fmt, std::forward<Args>(args)...);
} |
|
std::format даёт хорошую основу для создания специализированных функций форматирования:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| // Специализированные функции форматирования
inline std::string formatMoney(double amount, const std::string& currency) {
return std::format("{:.2f} {}", amount, currency);
}
inline std::string formatPercentage(double value) {
return std::format("{:.2f}%", value * 100.0);
}
inline std::string formatTimeAgo(std::chrono::system_clock::time_point time) {
auto now = std::chrono::system_clock::now();
auto diff = std::chrono::duration_cast<std::chrono::seconds>(now - time).count();
if (diff < 60) return std::format("{} секунд назад", diff);
if (diff < 3600) return std::format("{} минут назад", diff / 60);
if (diff < 86400) return std::format("{} часов назад", diff / 3600);
return std::format("{} дней назад", diff / 86400);
} |
|
std::format_to:
| C++ | 1
2
3
4
5
6
| // Для высоконагруженных участков
thread_local std::vector<char> tls_buffer(4096);
void highPerformanceLog(const std::string_view fmt, auto&&... args) {
auto result = std::format_to(tls_buffer.begin(), fmt, std::forward<decltype(args)>(args)...);
logToFile(std::string_view(tls_buffer.data(), result - tls_buffer.begin()));
} |
|
std::format практически всегда окупается – код становится чище, безопаснее и, как ни странно, часто быстрее. Даже в проектах, где исторически использовались сложные самописные решения для форматирования, переход на стандартный механизм в конечном счёте приводил к более поддерживаемому и лаконичному коду.
Главный вывод, который я сделал – std::format это не просто удобное API, а мощный строительный блок, на основе которого можно создавать элегантные высокоуровневые абстракции, специфичные для вашей предметной области. А как показывает практика, хорошие инструменты форматирования – это основа читаемого, поддерживаемого и понятного кода в любом проекте.
Не воспринимает ни std::cout, ни std::cin. Вобщем ничего из std. Также не понимает iostream
Здравствуйте!
Я хотел начать изучать язык C++. Набрал литературы. Установил Microsoft Visual C++... (std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&
astxx::manager::connection::connection(std::basic_string<char, std::char_traits<char>,... Ошибка: E2034 Cannot convert 'int' to 'std::vector<std::vector<TRabbitCell,std::allocator<TRabbitCell>>...
Есть двухмерный вектор:
std::vector<std::vector<TRabbitCell> > *cells(5, 10);
Пытаюсь... На основе исходного std::vector<std::string> содержащего числа, создать std::vector<int> с этими же числами
подскажите есть вот такая задача.
Есть список .
Создать второй список, в котором будут все эти же... Std::begin() ,std::end(),std::copy
...//
int main()
{
std::vector<double> data;//Работает
cout << std::begin(data);
... Std::bind, std::mem_fun, std::mem_fn
В чем разница между функциями std::bind, std::mem_fun, std::mem_fn? Std::unordered_multimap<std::string, std::unordered_multimap<int, int>>
Приветствую. Интересует вопрос, как можно обращаться к контейнеру?
Хотелось бы по map, но так не... std::pair<std::list<std::pair< >>::iterator, > ломается при возврате из функции
#include <iostream>
#include <list>
#include <string>
#include <utility>
using lp =... Поиск в std::vector < std::pair<UInt32, std::string> >
Подскажите пожалуйста, как осуществить поиск элемента в
std::vector < std::pair<UInt32,... std::shared_ptr и std::dynamic_pointer_cast, std::static_pointer_cast и т.д
Добрый день. Появился вопрос, операции std::shared_ptr, std::dynamic_pointer_cast,... std::wstring и std::u16string и std::u32string
Здравствуйте,
Подскажите пожалуйста, правильно ли я понимаю, что на Windows - std::wstring и... std::all_of, std::any_of, std::none_of
Хочу проверить, что не все символы в строке цифры.
можно проверить так:
if...
|
