Форматирование текста на C++ можно реализовать несколькими способами:
Первые два варианта представляют старые способы. Библиотека форматирования, очевидно, является новым. Но какой из них лучше в плане производительности? Это я и решил выяснить.
Для начала разберём простые примеры форматирования текста. Предположим, нам нужно отформатировать текст в виде "severity=1,error=42,reason=access denied". Это можно сделать так:
• с помощью потоков:
int severity = 1;
unsigned error = 42;
reason = "access denied";
std::stringstream ss;
ss << "severity=" << severity
<< ",error=" << error
<< ",reason=" << reason;
std::string text = ss.str();
• с помощью printf:
int severity = 1;
unsigned error = 42;
reason = "access denied";
std::string text(50, '\0');
sprintf(text.data(), "severity=%d,error=%u,reason=%s", severity, error, reason);
• с помощью format:
int severity = 1;
unsigned error = 42;
reason = "access denied";
std::string text = std::format("severity={},error={},reason={}", severity, error, reason);
// либо
std::string text;
std::format_to(std::back_inserter(text), "severity={},error={},reason={}", severity, error, reason);
Вариант с std::format во многом похож на printf, хотя здесь вам не нужно указывать спецификаторы типов, такие как %d, %u, %s, только плейсхолдер аргумента {}. Естественно, спецификаторы типов доступны, и о них можно почитать тут, но эта тема не относится к сути статьи.
Вариант с std::format_to полезен для добавления текста, поскольку производит запись в выходной буфер через итератор. Это позволяет нам присоединять текст условно, как в примере ниже, где reason записывается в сообщение, только если содержит что-либо:
std::string text = std::format("severity={},error={}", severity, error);
if(!reason.empty())
std::format_to(std::back_inserter(text), ",reason=", reason);
При всех этих вариантах возникает вопрос, а какой из них лучше? Как правило, потоковые операции медленные, в то время как {fmt} — отличается высокой скоростью. Но не все случаи равнозначны, и обычно, когда вы хотите внести оптимизацию, то должны оценить ситуацию, а не опираться на общее понимание.
Недавно я задал себе этот вопрос, когда заметил в своём текущем проекте обширное использование std::stringstream для форматирования сообщений журнала. В большинстве случаев там присутствует от одного до трёх аргументов. Вот пример:
std::stringstream ss;
ss << "component id: " << id;
std::string msg = ss.str();
// либо
std::stringstream ss;
ss << "source: " << source << "|code=" << code;
std::string msg = ss.str();
Я подумал, что замена std::stringstream на std::format должна положительно сказаться на быстродействии, но захотел оценить, насколько. Для сравнения альтернатив я написал приведённую ниже программу, которая работает так:
int main()
{
{
std::stringstream ss;
ss << 42;
}
using namespace std::chrono_literals;
std::random_device rd{};
auto mtgen = std::mt19937{ rd() };
auto ud = std::uniform_int_distribution<>{ -1000000, 1000000 };
std::vector<int> iterations{ 1, 2, 5, 10, 100, 1000, 10000, 100000, 1000000 };
std:
rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "iterations", "stringstream", "sprintf", "format_to", "format");
std:rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "----------", "------------", "-------", "---------", "------");
for (int count : iterations)
{
std::vector<int> numbers(count);
for (std::size_t i = 0; i < numbers.size(); ++i)
{
numbers = ud(mtgen);
}
long long t1, t2, t3, t4;
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::stringstream ss;
ss << "Number " << numbers << " is great!";
std::string s = ss.str();
}
auto end = std::chrono::high_resolution_clock::now();
t1 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string str(100, '\0');
std::sprintf(str.data(), "Number %d is great!", numbers);
}
auto end = std::chrono::high_resolution_clock::now();
t2 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s;
std::format_to(std::back_inserter(s), "Number {} is great!", numbers);
}
auto end = std::chrono::high_resolution_clock::now();
t3 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s = std::format("Number {} is great!", numbers);
}
auto end = std::chrono::high_resolution_clock::now();
t4 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
std:rintln("{:<10} {:<12.2f} {:<7.2f} {:<9.2f} {:<7.2f}", count, t1/1000.0 / count, t2 / 1000.0 / count, t3 / 1000.0 / count, t4 / 1000.0 / count);
}
}
Результаты каждого выполнения немного отличаются и на разных машинах тоже будут разными. На моей 64-битная версия программы выдаёт следующие показатели (время в мкс):
Если прогнать цикл один раз, то sprintf, как правило, оказывается в 2-3 раза быстрее std::stringstream. При этом std::format/std::format_to опережают std::stringstream в 20-30 раз, оказываясь быстрее sprintf в 5-20 раз. При увеличении количества итераций эти показатели изменяются, но std::format всё равно остаётся примерно в 5 раз быстрее std::stringstream и чаще всего наравне с sprintf. Поскольку в моём случае генерация сообщений журнала не выполняется в цикле, я могу заключить, что ускорение может составить 20-30 крат.
В случае когда в выходной текст записываются 2 аргумента, показатели оказываются схожи. Для генерации текста в виде "Numbers 42 and 43 are great!" программа отличается лишь немного:
int main()
{
{
std::stringstream ss;
ss << 42;
}
using namespace std::chrono_literals;
std::random_device rd{};
auto mtgen = std::mt19937{ rd() };
auto ud = std::uniform_int_distribution<>{ -1000000, 1000000 };
std::vector<int> iterations{ 1, 2, 5, 10, 100, 1000, 10000, 100000, 1000000 };
std:rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "iterations", "stringstream", "sprintf", "format_to", "format");
std:rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "----------", "------------", "-------", "---------", "------");
for (int count : iterations)
{
std::vector<int> numbers(count);
for (std::size_t i = 0; i < numbers.size(); ++i)
{
numbers = ud(mtgen);
}
long long t1, t2, t3, t4;
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::stringstream ss;
ss << "Numbers " << numbers << " and " << numbers + 1 << " are great!";
std::string s = ss.str();
}
auto end = std::chrono::high_resolution_clock::now();
t1 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string str(100, '\0');
sprintf(str.data(), "Numbers %d and %d are great!", numbers, numbers + 1);
}
auto end = std::chrono::high_resolution_clock::now();
t2 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s;
std::format_to(std::back_inserter(s), "Numbers {} and {} are great!", numbers, numbers + 1);
}
auto end = std::chrono::high_resolution_clock::now();
t3 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s = std::format("Numbers {} and {} are great!", numbers, numbers + 1);
}
auto end = std::chrono::high_resolution_clock::now();
t4 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
std:rintln("{:<10} {:<12.2} {:<7.2} {:<9.2} {:<7.2}", count, t1 / 1000.0 / count, t2 / 1000.0 / count, t3 / 1000.0 / count, t4 / 1000.0 / count);
}
}
Результаты оказываются в том же диапазоне, что и прежде. Хотя, опять же, от выполнения к выполнению отличаются:
Несмотря на то, что в большинстве случаев перейти с std::stringstream на std::format легко, существуют определённые отличия, требующие дополнительной работы. К примерам можно отнести форматирование указателей и массивов беззнаковых символов.
Можно легко записать значение указателя в буфер вывода следующим образом:
int a = 42;
std::stringstream ss;
ss << "address=" << &a;
std::string text = ss.str();
Итоговый текст будет иметь вид "address=00000004D4DAE218". Но с std::format этот вариант не сработает:
int a = 42;
std::string text = std::format("address={}", &a); // ошибка; не знает, как форматировать
Данный фрагмент кода выдаст ошибки (отличающиеся в зависимости от компилятора), поскольку не знает, как форматировать указатель. Вы можете получить те же результаты, что и прежде, рассматривая указатель как значение std::size_t и используя спецификатор форматирования, такой как :016X (16 шестнадцатеричных цифр с ведущими нулями):
std::string text = std::format("address={:016X}", reinterpret_cast<std::size_t>(&a));
Теперь результат будет одинаковым (хотя нужно помнить, что для 32-битных указателей используется лишь 8 шестнадцатеричных цифр).
Вот ещё один пример с массивами беззнаковых символов, которые std::stringstream при записи в буфер вывода преобразует в char:
unsigned char str[]{3,4,5,6,0};
std::stringstream ss;
ss << "str=" << str;
std::string text = ss.str();
Содержимым текста будет "str=♥♦♣♠".
Попытка проделать то же самое с помощью std::format снова провалится, поскольку эта команда не знает, как форматировать массив:
std::string text = std::format("str={}", str); // ошибка; не знает, как форматировать
Можно записать содержимое массива с помощью цикла так:
std::string text = "str=";
for (auto c : str)
std::format_to(std::back_inserter(text), "{}", c);
Содержимым текста будет "str=34560", потому что каждый unsigned char записывается в буфер вывода как есть без приведения. Чтобы получить те же результаты, что и прежде, необходимо выполнить приведение явно:
std::string text = "str=";
for (auto c : str)
std::format_to(std::back_inserter(text), "{}", static_cast<char>(c));
Если вы форматируете текст для вывода в консоль и используете результат std::format / std::format_to через std::cout (или другие альтернативы), то в С++23, где появились std:rint и std:rintln, для этого нет необходимости:
int severity = 1;
unsigned error = 42;
reason = "access denied";
std:rintln("severity={},error={},reason={}", severity, error, reason);
habr.com
- потоками ввода-вывода. В частности, через std::stringstream с помощью потоковых операций (таких как operator <<);
- функциями printf, в частности sprintf;
- с помощью библиотеки форматирования C++20, в частности std::format / std::format_to;
- с помощью сторонней библиотеки, в частности {fmt} (основа новой стандартной библиотеки форматирования).
Первые два варианта представляют старые способы. Библиотека форматирования, очевидно, является новым. Но какой из них лучше в плане производительности? Это я и решил выяснить.
▍ Примеры
Для начала разберём простые примеры форматирования текста. Предположим, нам нужно отформатировать текст в виде "severity=1,error=42,reason=access denied". Это можно сделать так:
• с помощью потоков:
int severity = 1;
unsigned error = 42;
reason = "access denied";
std::stringstream ss;
ss << "severity=" << severity
<< ",error=" << error
<< ",reason=" << reason;
std::string text = ss.str();
• с помощью printf:
int severity = 1;
unsigned error = 42;
reason = "access denied";
std::string text(50, '\0');
sprintf(text.data(), "severity=%d,error=%u,reason=%s", severity, error, reason);
• с помощью format:
int severity = 1;
unsigned error = 42;
reason = "access denied";
std::string text = std::format("severity={},error={},reason={}", severity, error, reason);
// либо
std::string text;
std::format_to(std::back_inserter(text), "severity={},error={},reason={}", severity, error, reason);
Вариант с std::format во многом похож на printf, хотя здесь вам не нужно указывать спецификаторы типов, такие как %d, %u, %s, только плейсхолдер аргумента {}. Естественно, спецификаторы типов доступны, и о них можно почитать тут, но эта тема не относится к сути статьи.
Вариант с std::format_to полезен для добавления текста, поскольку производит запись в выходной буфер через итератор. Это позволяет нам присоединять текст условно, как в примере ниже, где reason записывается в сообщение, только если содержит что-либо:
std::string text = std::format("severity={},error={}", severity, error);
if(!reason.empty())
std::format_to(std::back_inserter(text), ",reason=", reason);
▍ Сравнение производительности
При всех этих вариантах возникает вопрос, а какой из них лучше? Как правило, потоковые операции медленные, в то время как {fmt} — отличается высокой скоростью. Но не все случаи равнозначны, и обычно, когда вы хотите внести оптимизацию, то должны оценить ситуацию, а не опираться на общее понимание.
Недавно я задал себе этот вопрос, когда заметил в своём текущем проекте обширное использование std::stringstream для форматирования сообщений журнала. В большинстве случаев там присутствует от одного до трёх аргументов. Вот пример:
std::stringstream ss;
ss << "component id: " << id;
std::string msg = ss.str();
// либо
std::stringstream ss;
ss << "source: " << source << "|code=" << code;
std::string msg = ss.str();
Я подумал, что замена std::stringstream на std::format должна положительно сказаться на быстродействии, но захотел оценить, насколько. Для сравнения альтернатив я написал приведённую ниже программу, которая работает так:
- форматирует текст в виде "Number 42 is great!";
- сравнивает std::stringstream, sprintf, std::format и std::format_to;
- выполняет переменное число итераций, от 1 до 1000000, и определяет среднее время одной итерации.
int main()
{
{
std::stringstream ss;
ss << 42;
}
using namespace std::chrono_literals;
std::random_device rd{};
auto mtgen = std::mt19937{ rd() };
auto ud = std::uniform_int_distribution<>{ -1000000, 1000000 };
std::vector<int> iterations{ 1, 2, 5, 10, 100, 1000, 10000, 100000, 1000000 };
std:
rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "iterations", "stringstream", "sprintf", "format_to", "format");std:
rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "----------", "------------", "-------", "---------", "------");for (int count : iterations)
{
std::vector<int> numbers(count);
for (std::size_t i = 0; i < numbers.size(); ++i)
{
numbers = ud(mtgen);
}
long long t1, t2, t3, t4;
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::stringstream ss;
ss << "Number " << numbers << " is great!";
std::string s = ss.str();
}
auto end = std::chrono::high_resolution_clock::now();
t1 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string str(100, '\0');
std::sprintf(str.data(), "Number %d is great!", numbers);
}
auto end = std::chrono::high_resolution_clock::now();
t2 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s;
std::format_to(std::back_inserter(s), "Number {} is great!", numbers);
}
auto end = std::chrono::high_resolution_clock::now();
t3 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s = std::format("Number {} is great!", numbers);
}
auto end = std::chrono::high_resolution_clock::now();
t4 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
std:
rintln("{:<10} {:<12.2f} {:<7.2f} {:<9.2f} {:<7.2f}", count, t1/1000.0 / count, t2 / 1000.0 / count, t3 / 1000.0 / count, t4 / 1000.0 / count);}
}
Результаты каждого выполнения немного отличаются и на разных машинах тоже будут разными. На моей 64-битная версия программы выдаёт следующие показатели (время в мкс):
| Количество итераций | stringstream | sprintf | format_to | format |
| 1 | 29.60 | 11.80 | 1.80 | 0.60 |
| 2 | 10.00 | 4.20 | 0.55 | 0.50 |
| 5 | 1.56 | 0.56 | 0.34 | 0.26 |
| 10 | 1.61 | 1.15 | 0.26 | 0.31 |
| 100 | 1.15 | 0.28 | 0.22 | 0.26 |
| 1000 | 1.17 | 0.30 | 0.24 | 0.26 |
| 10 000 | 1.29 | 0.28 | 0.23 | 0.24 |
| 100 000 | 0.87 | 0.18 | 0.15 | 0.16 |
| 1 000 000 | 0.74 | 0.18 | 0.15 | 0.16 |
В случае когда в выходной текст записываются 2 аргумента, показатели оказываются схожи. Для генерации текста в виде "Numbers 42 and 43 are great!" программа отличается лишь немного:
int main()
{
{
std::stringstream ss;
ss << 42;
}
using namespace std::chrono_literals;
std::random_device rd{};
auto mtgen = std::mt19937{ rd() };
auto ud = std::uniform_int_distribution<>{ -1000000, 1000000 };
std::vector<int> iterations{ 1, 2, 5, 10, 100, 1000, 10000, 100000, 1000000 };
std:
rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "iterations", "stringstream", "sprintf", "format_to", "format");std:
rintln("{:>10} {:>12} {:>7} {:>9} {:>6}", "----------", "------------", "-------", "---------", "------");for (int count : iterations)
{
std::vector<int> numbers(count);
for (std::size_t i = 0; i < numbers.size(); ++i)
{
numbers = ud(mtgen);
}
long long t1, t2, t3, t4;
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::stringstream ss;
ss << "Numbers " << numbers << " and " << numbers + 1 << " are great!";
std::string s = ss.str();
}
auto end = std::chrono::high_resolution_clock::now();
t1 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string str(100, '\0');
sprintf(str.data(), "Numbers %d and %d are great!", numbers, numbers + 1);
}
auto end = std::chrono::high_resolution_clock::now();
t2 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s;
std::format_to(std::back_inserter(s), "Numbers {} and {} are great!", numbers, numbers + 1);
}
auto end = std::chrono::high_resolution_clock::now();
t3 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
{
auto start = std::chrono::high_resolution_clock::now();
for (std::size_t i = 0; i < numbers.size(); ++i)
{
std::string s = std::format("Numbers {} and {} are great!", numbers, numbers + 1);
}
auto end = std::chrono::high_resolution_clock::now();
t4 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}
std:
rintln("{:<10} {:<12.2} {:<7.2} {:<9.2} {:<7.2}", count, t1 / 1000.0 / count, t2 / 1000.0 / count, t3 / 1000.0 / count, t4 / 1000.0 / count);}
}
Результаты оказываются в том же диапазоне, что и прежде. Хотя, опять же, от выполнения к выполнению отличаются:
| Количество итераций | stringstream | sprintf | format_to | format |
| 1 | 27 | 4.7 | 5.8 | 0.8 |
| 2 | 8.1 | 1.4 | 0.9 | 0.75 |
| 5 | 3.4 | 0.8 | 0.62 | 0.46 |
| 10 | 4.3 | 0.82 | 0.44 | 0.38 |
| 100 | 1.9 | 0.45 | 0.31 | 0.33 |
| 1000 | 1.9 | 0.46 | 0.37 | 0.35 |
| 10 000 | 1.8 | 0.38 | 0.29 | 0.31 |
| 100 000 | 1.3 | 0.26 | 0.22 | 0.24 |
| 1 000 000 | 1.2 | 0.27 | 0.23 | 0.25 |
▍ Совместимость
Несмотря на то, что в большинстве случаев перейти с std::stringstream на std::format легко, существуют определённые отличия, требующие дополнительной работы. К примерам можно отнести форматирование указателей и массивов беззнаковых символов.
Можно легко записать значение указателя в буфер вывода следующим образом:
int a = 42;
std::stringstream ss;
ss << "address=" << &a;
std::string text = ss.str();
Итоговый текст будет иметь вид "address=00000004D4DAE218". Но с std::format этот вариант не сработает:
int a = 42;
std::string text = std::format("address={}", &a); // ошибка; не знает, как форматировать
Данный фрагмент кода выдаст ошибки (отличающиеся в зависимости от компилятора), поскольку не знает, как форматировать указатель. Вы можете получить те же результаты, что и прежде, рассматривая указатель как значение std::size_t и используя спецификатор форматирования, такой как :016X (16 шестнадцатеричных цифр с ведущими нулями):
std::string text = std::format("address={:016X}", reinterpret_cast<std::size_t>(&a));
Теперь результат будет одинаковым (хотя нужно помнить, что для 32-битных указателей используется лишь 8 шестнадцатеричных цифр).
Вот ещё один пример с массивами беззнаковых символов, которые std::stringstream при записи в буфер вывода преобразует в char:
unsigned char str[]{3,4,5,6,0};
std::stringstream ss;
ss << "str=" << str;
std::string text = ss.str();
Содержимым текста будет "str=♥♦♣♠".
Попытка проделать то же самое с помощью std::format снова провалится, поскольку эта команда не знает, как форматировать массив:
std::string text = std::format("str={}", str); // ошибка; не знает, как форматировать
Можно записать содержимое массива с помощью цикла так:
std::string text = "str=";
for (auto c : str)
std::format_to(std::back_inserter(text), "{}", c);
Содержимым текста будет "str=34560", потому что каждый unsigned char записывается в буфер вывода как есть без приведения. Чтобы получить те же результаты, что и прежде, необходимо выполнить приведение явно:
std::string text = "str=";
for (auto c : str)
std::format_to(std::back_inserter(text), "{}", static_cast<char>(c));
▍ Кстати
Если вы форматируете текст для вывода в консоль и используете результат std::format / std::format_to через std::cout (или другие альтернативы), то в С++23, где появились std:
rint и std:rintln, для этого нет необходимости:int severity = 1;
unsigned error = 42;
reason = "access denied";
std:
rintln("severity={},error={},reason={}", severity, error, reason);
Форматирование текста на C++ старым и новым способом
Форматирование текста на C++ можно реализовать несколькими способами: потоками ввода-вывода. В частности, через std::stringstream с помощью потоковых операций (таких как operator << );...
habr.com