When it comes to format a piece of text in C++ there are several ways you can employ:<\/p>\n\n\n\n
operator <<<\/code>)<\/li>- printf family of functions, particularly sprintf<\/a><\/li>
- the C++20 format library, particularly std::format<\/a> \/ std::format_to<\/a><\/li>
- any 3rd party library, {fmt}<\/a> in particular (the source of the new standard format library)<\/li><\/ul>\n\n\n\n
The first two options represent the old ways. The format library, is, obviously, the new, modern way of formatting text. But which is better in terms of performance? Let’s try to figure out.<\/p>\n\n\n\n
In which examples are presented…<\/h2>\n\n\n\n
First, let’s see a few simple examples of formatting text. Let’s say we want to format a text in the form \"severity=1,error=42,reason=access denied\"<\/code>. We can do this as follows:<\/p>\n\n\n\n- with streams<\/li><\/ul>\n\n\n\n
int severity = 1;\nunsigned error = 42;\nreason = \"access denied\";\n\nstd::stringstream ss;\nss << \"severity=\" << severity\n << \",error=\" << error\n << \",reason=\" << reason;\n\nstd::string text = ss.str();<\/pre>\n\n\n\n
- with printf<\/li><\/ul>\n\n\n\n
int severity = 1;\nunsigned error = 42;\nreason = \"access denied\";\n\nstd::string text(50, '\\0');\nsprintf(text.data(), \"severity=%d,error=%u,reason=%s\", severity, error, reason);<\/pre>\n\n\n\n
- with format<\/li><\/ul>\n\n\n\n
int severity = 1;\nunsigned error = 42;\nreason = \"access denied\";\n\nstd::string text = std::format(\"severity={},error={},reason={}\", severity, error, reason);\n\n\/\/ or\n\nstd::string text;\nstd::format_to(std::back_inserter(text), \"severity={},error={},reason={}\", severity, error, reason);<\/pre>\n\n\n\nstd::format<\/code> is very similar in many aspects to printf<\/code>, although you don’t need to provide type specifiers, such as %d<\/code>, %u<\/code>, %s<\/code>, only an argument placeholder {}<\/code>. Of course, there are format specifiers available, which you can read about here<\/a>, but that’s not of interest for the point of this article.<\/p>\n\n\n\nThe std::format_to<\/code> is useful to append text because it writes to an output buffer through an iterator. This allows us to append text, conditionally, such as in the following example where the reason is written in the message only if it’s not empty:<\/p>\n\n\n\nstd::string text = std::format(\"severity={},error={}\", severity, error);\n\nif(!reason.empty())\n std::format_to(std::back_inserter(text), \",reason=\", reason);<\/pre>\n\n\n\nIn which performance is compared…<\/h2>\n\n\n\n
With all these options, the question is which is the best to use? In general, stream operations are slow, and {fmt}<\/code> is known to be significantly faster. But not all cases are equal, and, in general, when you want to make optimizations, you should measure yourself and not take decisions based on generalities.<\/p>\n\n\n\nI asked myself this question recently, when I noticed in a project that I’m currently involved with the large scale use of std::stringstream<\/code> to format log messages. Most examples involved one to three arguments. For instance:<\/p>\n\n\n\nstd::stringstream ss;\nss << \"component id: \" << id;\n\nstd::string msg = ss.str();\n\n\/\/ or\n\nstd::stringstream ss;\nss << \"source: \" << source << \"|code=\" << code;\n\nstd::string msg = ss.str();<\/pre>\n\n\n\nI thought that replacing std::stringstream<\/code> with std::format<\/code> should be beneficial for performance, but I wanted to measure how much faster it would be. So I wrote the following program to compare the alternatives. What it does is:<\/p>\n\n\n\n- format a text to the form
\"Number 42 is great!\"<\/code><\/li>- compares
std::stringstream<\/code>, sprintf<\/code>, std::format<\/code>, and std::format_to<\/code><\/li>- runs a variable number of iterations, 1 to 1000000, and determines the average time per iteration<\/li><\/ul>\n\n\n\n
int main()\n{\n {\n std::stringstream ss;\n ss << 42;\n }\n\n using namespace std::chrono_literals;\n\n std::random_device rd{};\n auto mtgen = std::mt19937{ rd() };\n auto ud = std::uniform_int_distribution<>{ -1000000, 1000000 };\n\n std::vector<int> iterations{ 1, 2, 5, 10, 100, 1000, 10000, 100000, 1000000 };\n\n std::println(\"{:>10} {:>12} {:>7} {:>9} {:>6}\", \"iterations\", \"stringstream\", \"sprintf\", \"format_to\", \"format\");\n std::println(\"{:>10} {:>12} {:>7} {:>9} {:>6}\", \"----------\", \"------------\", \"-------\", \"---------\", \"------\");\n\n for (int count : iterations)\n {\n std::vector<int> numbers(count);\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n numbers[i] = ud(mtgen);\n }\n\n long long t1, t2, t3, t4;\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::stringstream ss;\n ss << \"Number \" << numbers[i] << \" is great!\";\n std::string s = ss.str();\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t1 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::string str(100, '\\0');\n std::sprintf(str.data(), \"Number %d is great!\", numbers[i]);\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t2 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::string s;\n std::format_to(std::back_inserter(s), \"Number {} is great!\", numbers[i]);\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t3 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::string s = std::format(\"Number {} is great!\", numbers[i]);\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t4 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n std::println(\"{:<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);\n }\n}<\/pre>\n\n\n\nThe results vary slightly for each execution, and, as one would expect, should be different on different machines. On my machine, a Release build for 64-bit produces results as following (time values are given in microseconds):<\/p>\n\n\n\n
iterations stringstream sprintf format_to format\n---------- ------------ ------- --------- ------\n1 29.60 11.80 1.80 0.60\n2 10.00 4.20 0.55 0.50\n5 1.56 0.56 0.34 0.26\n10 1.61 1.15 0.26 0.31\n100 1.15 0.28 0.22 0.26\n1000 1.17 0.30 0.24 0.26\n10000 1.29 0.28 0.23 0.24\n100000 0.87 0.18 0.15 0.16\n1000000 0.74 0.18 0.15 0.16<\/pre>\n\n\n\nIf we ran the loop a single time, the sprintf<\/code> is 2-3 times faster, in general, than std::stringstream<\/code>, but std::format<\/code>\/std::format<\/code> are 20-30x times faster than std::stringstream<\/code> and 5-20x faster than sprintf<\/code>. These numbers change as we measure the execution of more loops, but still, std::format<\/code> is still about 5 times faster than std::stringstream<\/code> and mostly the same with sprintf<\/code>. Since in my case generating a log message does not occur in a loop, I can conclude that the speed-up can be 20-30x.<\/p>\n\n\n\nFor the case when 2 arguments are written in the output text, the numbers are similar. The program is only slightly different, to generate text of the form \"Numbers 42 and 43 are great!\"<\/code>:<\/p>\n\n\n\nint main()\n{\n {\n std::stringstream ss;\n ss << 42;\n }\n\n using namespace std::chrono_literals;\n\n std::random_device rd{};\n auto mtgen = std::mt19937{ rd() };\n auto ud = std::uniform_int_distribution<>{ -1000000, 1000000 };\n\n std::vector<int> iterations{ 1, 2, 5, 10, 100, 1000, 10000, 100000, 1000000 };\n\n std::println(\"{:>10} {:>12} {:>7} {:>9} {:>6}\", \"iterations\", \"stringstream\", \"sprintf\", \"format_to\", \"format\");\n std::println(\"{:>10} {:>12} {:>7} {:>9} {:>6}\", \"----------\", \"------------\", \"-------\", \"---------\", \"------\");\n\n for (int count : iterations)\n {\n std::vector<int> numbers(count);\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n numbers[i] = ud(mtgen);\n }\n\n long long t1, t2, t3, t4;\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::stringstream ss;\n ss << \"Numbers \" << numbers[i] << \" and \" << numbers[i] + 1 << \" are great!\";\n std::string s = ss.str();\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t1 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::string str(100, '\\0');\n sprintf(str.data(), \"Numbers %d and %d are great!\", numbers[i], numbers[i] + 1);\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t2 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::string s;\n std::format_to(std::back_inserter(s), \"Numbers {} and {} are great!\", numbers[i], numbers[i] + 1);\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t3 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n {\n auto start = std::chrono::high_resolution_clock::now();\n\n for (std::size_t i = 0; i < numbers.size(); ++i)\n {\n std::string s = std::format(\"Numbers {} and {} are great!\", numbers[i], numbers[i] + 1);\n }\n\n auto end = std::chrono::high_resolution_clock::now();\n t4 = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();\n }\n\n std::println(\"{:<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);\n }\n}<\/pre>\n\n\n\nThe results are in the same range as shown previously (although, again, they vary from one execution to another):<\/p>\n\n\n\n
iterations stringstream sprintf format_to format\n---------- ------------ ------- --------- ------\n1 27 4.7 5.8 0.8\n2 8.1 1.4 0.9 0.75\n5 3.4 0.8 0.62 0.46\n10 4.3 0.82 0.44 0.38\n100 1.9 0.45 0.31 0.33\n1000 1.9 0.46 0.37 0.35\n10000 1.8 0.38 0.29 0.31\n100000 1.3 0.26 0.22 0.24\n1000000 1.2 0.27 0.23 0.25<\/pre>\n\n\n\nIn which compatibility of formatting is discussed…<\/h2>\n\n\n\n
Although in most cases, moving from std::stringstream<\/code> to std::format<\/code> is straight forward, there are some things that are not the same and, therefore, require extra work. Examples include formatting pointers and arrays of unsigned characters.<\/p>\n\n\n\nYou can easily write the value of a pointer to an output buffer as follows:<\/p>\n\n\n\n
int a = 42;\n\nstd::stringstream ss;\nss << \"address=\" << &a;\nstd::string text = ss.str();<\/pre>\n\n\n\nThe text will have the form \"address=00000004D4DAE218\"<\/code>. But this does not work with std::format<\/code>:<\/p>\n\n\n\nint a = 42;\n\nstd::string text = std::format(\"address={}\", &a); \/\/ error, does not know how to format<\/pre>\n\n\n\nThis snippet will generate errors (that vary with the compiler) because it does not know how to format the pointer. You can obtain the same result as previously, treating the pointer like a std:size_t<\/code> value and using a format specifier such as :016X<\/code> (16 hexadecimal uppercase digits with leading zeros):<\/p>\n\n\n\nstd::string text = std::format(\"address={:016X}\", reinterpret_cast<std::size_t>(&a));<\/pre>\n\n\n\nNow, the result will be the same (although you should keep in mind that for 32-bit the pointers are only 8 hexadecimal digits).<\/p>\n\n\n\n
Here is another example with arrays of unsigned characters, that std::stringstream<\/code> converts to char<\/code> when writing to the output buffer:<\/p>\n\n\n\nunsigned char str[]{3,4,5,6,0};\n\nstd::stringstream ss;\nss << \"str=\" << str;\nstd::string text = ss.str();<\/pre>\n\n\n\nThe content of text will be \"str=\u2665\u2666\u2663\u2660\"<\/code>.<\/p>\n\n\n\nTrying the same with std::format<\/code>, will fail again because it does not know how to format the array:<\/p>\n\n\n\nstd::string text = std::format(\"str={}\", str); \/\/ error, does not now how to format<\/pre>\n\n\n\nWe can write the content of the array in a loop, as follows:<\/p>\n\n\n\n
std::string text = \"str=\";\nfor (auto c : str)\n std::format_to(std::back_inserter(text), \"{}\", c);<\/pre>\n\n\n\nThe content of the text will be \"str=34560\"<\/code> because every unsigned char<\/code> is written as such to the output buffer, without any casting. To obtain the same result as previously, you need to perform a cast explicitly:<\/p>\n\n\n\nstd::string text = \"str=\";\nfor (auto c : str)\n std::format_to(std::back_inserter(text), \"{}\", static_cast<char>(c));<\/pre>\n\n\n\nBonus talk<\/h2>\n\n\n\n
If you’re formatting text to be written to the output console and use the result of std::format<\/code> \/ std::format_to<\/code> with std::cout<\/code> (or other alternatives) there is no need for that in C++23, which introduced std::print<\/a> and std::println<\/a>:<\/p>\n\n\n\nint severity = 1;\nunsigned error = 42;\nreason = \"access denied\";\n\nstd::println(\"severity={},error={},reason={}\", severity, error, reason);<\/pre>\n","protected":false},"excerpt":{"rendered":"When it comes to format a piece of text in C++ there are several ways you can employ: I\/O streams, particularly std::stringstream with stream operations (such as operator <<) printf family of functions, particularly sprintf the C++20 format library, particularly std::format \/ std::format_to any 3rd party library, {fmt} in particular (the source of the new … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[7],"tags":[451,543,646],"class_list":["post-4687","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-c20","tag-format"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t