{"id":9057,"date":"2024-02-05T10:40:23","date_gmt":"2024-02-05T10:40:23","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=9057"},"modified":"2024-02-05T10:47:19","modified_gmt":"2024-02-05T10:47:19","slug":"the-formatting-library-in-c20-the-format-string-2","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/the-formatting-library-in-c20-the-format-string-2\/","title":{"rendered":"The Formatting Library in C++20: The Format String (2)"},"content":{"rendered":"\n

In my last post, “The Formatting Library in C++20: The Format String<\/a>“, I presented a few of the format specifications of the format string. Today, I finish my job.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

In today’s post, I will write about the width, precision, and type of the format specification. If you want to know more about the argument id, fill characters, alignment, signess, and the alternative form, read my previous post: “The Formatting Library in C++20: The Format String<\/a>“.<\/p>\n\n\n\n

Width and Precision<\/h2>\n\n\n\n

You can specify the width and the precision of your argument. The width specifier can be applied to numbers, and the precision to floating-point numbers and strings. For floating-point types, the precision specifies the formatting precision; for strings, the precision specifies how many characters are used and, ultimately, trimming the string. It does not affect a string if the precision is greater than the length of the string.<\/p>\n\n\n\n

    \n
  • width: you can use either a positive decimal number or a replacement field ({}<\/code> or {n}<\/code>). When given, n <\/code>specifies the minimum width.<\/li>\n\n\n\n
  • precision: you can use a period (.)<\/code> followed by a non-negative decimal number or a replacement field.<\/li>\n<\/ul>\n\n\n\n

    A few examples should help you grasp the basics:<\/p>\n\n\n\n

    \/\/ formatWidthPrecision.cpp<\/span>\n\n#include <format><\/span>\n#include <iostream><\/span>\n#include <string><\/span>\n\nint<\/span> main<\/span>() {\n\n    int<\/span> i =<\/span> 123456789<\/span>;\n    double<\/span> d =<\/span> 123.456789<\/span>;\n\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{}"<\/span>, i) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:15}"<\/span>, i) <<<\/span> "---<\/span>\\n<\/span>"<\/span>; \/\/ (w = 15)<\/span>\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:}"<\/span>, i) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;   \/\/ (w = 15)             \/\/ (1)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{}"<\/span>, d) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;    \n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:15}"<\/span>, d) <<<\/span> "---<\/span>\\n<\/span>"<\/span>; \/\/ (w = 15)<\/span>\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:}"<\/span>, d) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;   \/\/ (w = 15)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>string s=<\/span> "Only a test"<\/span>;\n\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:10.50}"<\/span>, d) <<<\/span> "---<\/span>\\n<\/span>"<\/span>; \/\/ (w = 10, p = 50)   \/\/ (2)<\/span>\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:{}.{}}"<\/span>, d, 10<\/span>, 50<\/span>) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;  \/\/ (w = 10,  \/\/ (3)<\/span>\n                                                                         \/\/  p = 50)<\/span>\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:10.5}"<\/span>, d) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;  \/\/ (w = 10, p = 5)<\/span>\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:{}.{}}"<\/span>, d, 10<\/span>, 5<\/span>) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;  \/\/ (w = 10,<\/span>\n                                                                         \/\/  p = 5)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:.500}"<\/span>, s) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;      \/\/ (p = 500)      \/\/ (4)<\/span>\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:.{}}"<\/span>, s, 500<\/span>) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;  \/\/ (p = 500)      \/\/ (5)<\/span>\n    std::<\/span>cout <<<\/span> "---"<\/span> <<<\/span> std::<\/span>format("{:.5}"<\/span>, s) <<<\/span> "---<\/span>\\n<\/span>"<\/span>;        \/\/ (p = 5)<\/span>\n\n}\n<\/pre><\/div>\n\n\n\n
    The w<\/code> character in the source code stands for the width; similarly, the p<\/code> character for the precision. I have a few interesting observations about the program. No extra spaces are added when you specify the width with a replacement field (line 1). When you specify a precision higher than the length of the displayed double<\/code> (lines 2 and 3), the length of the displayed value reflects the precision. This observation does not hold for a string (lines 4 and 5).<\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    Additionally, you can also parametrize the width and the precision.<\/p>\n\n\n\n
    \/\/ formatWidthPrecisionParametrized.cpp<\/span>\n\n#include <format><\/span>\n#include <iostream><\/span>\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    double<\/span> doub =<\/span> 123.456789<\/span>;\n\n    std::<\/span>cout <<<\/span> std::<\/span>format("{:}<\/span>\\n<\/span>"<\/span>, doub);                          \/\/ (1)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    for<\/span> (auto<\/span> precision:<\/span> {3<\/span>, 5<\/span>, 7<\/span>, 9<\/span>}) {\n       std::<\/span>cout <<<\/span> std::<\/span>format("{:.{}}<\/span>\\n<\/span>"<\/span>, doub, precision);         \/\/ (2)<\/span>\n    }\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    int<\/span> width =<\/span> 10<\/span>;\n    for<\/span> (auto<\/span> precision:<\/span> {3<\/span>, 5<\/span>, 7<\/span>, 9<\/span>}) {\n       std::<\/span>cout <<<\/span> std::<\/span>format("{:{}.{}}<\/span>\\n<\/span>"<\/span>, doub, width, precision); \/\/ (3)<\/span>\n    }\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
    The program formatWidthPrecisionParametrized.cpp <\/code>displays the double doub <\/code>in various ways. Line (1) applies the default. Line (2) varies  precision<\/code> from 3 to 9. The last argument of the format string goes into the inner {}<\/code> of the format specifier {:.{}}<\/code>. Finally, line (3) sets the width of the displayed doubles to 10. \u00a0<\/p>\n\n\n\n
    \"\"<\/figure>\n\n\n\n
    Type<\/h2>\n\n\n\n
    In general, the compiler deduces the type of the value used. But sometimes, you want to specify the type. These are the most important type specifications:<\/p>\n\n\n\n
    Strings<\/strong>: s<\/code><\/p>\n\n\n\n
    Integers<\/strong>:<\/p>\n\n\n\n
      \n
    • b<\/code>: binary format<\/li>\n\n\n\n
    • B<\/code>: same as b<\/code>, but the base prefix is 0B<\/code><\/li>\n\n\n\n
    • d<\/code>: decimal format<\/li>\n\n\n\n
    • o<\/code>: octal format<\/li>\n\n\n\n
    • x<\/code>: hexadecimal format<\/li>\n\n\n\n
    • X<\/code>: same as x<\/code>, but the base prefix is 0X<\/code><\/li>\n<\/ul>\n\n\n\n
      char<\/strong><\/code> and wchar_t<\/code><\/strong>:<\/p>\n\n\n\n
        \n
      •  b, B, d, o, x, X<\/code>: such as integers<\/li>\n<\/ul>\n\n\n\n
        bool<\/code><\/strong>:<\/p>\n\n\n\n
          \n
        • s: true<\/code> or false<\/code><\/li>\n\n\n\n
        • b, B, d, o, x, X<\/code>: such as integers<\/li>\n<\/ul>\n\n\n\n
          Floating-point<\/strong>:<\/p>\n\n\n\n
            \n
          • e<\/code>: exponential format<\/li>\n\n\n\n
          • E<\/code>: same as e<\/code>, but the exponent is written with E<\/code><\/li>\n\n\n\n
          • f, F<\/code>: fixed point; precision is 6<\/li>\n\n\n\n
          • g, G<\/code>: precision 6, but the exponent is written with E<\/code><\/li>\n<\/ul>\n\n\n\n
            Pointer<\/strong>:<\/p>\n\n\n\n
              \n
            • p<\/code>: hexadecimal notation of its address<\/li>\n<\/ul>\n\n\n\n
              Only void<\/code>, const void<\/code>, and std::nullptr_t<\/code> pointer types are valid. If you want to display the address of an arbitrary pointer, you must cast it to (const) void*<\/code>.<\/p>\n\n\n\n
              double<\/span> d =<\/span> 123.456789<\/span>;\n\nstd::<\/span>format("{}"<\/span>, &<\/span>d);                           \/\/ ERROR<\/span>\nstd::<\/span>format("{}"<\/span>, static_cast<\/span><<\/span>void<\/span>*><\/span>(&<\/span>d));       \/\/ okay<\/span>\nstd::<\/span>format("{}"<\/span>, static_cast<\/span><<\/span>const<\/span> void<\/span>*><\/span>(&<\/span>d)); \/\/ okay<\/span>\nstd::<\/span>format("{}"<\/span>, nullptr);                      \/\/ okay<\/span>\n<\/pre><\/div>\n\n\n\n
              The type specifiers allow you to display an int<\/code> in a different number system.<\/p>\n\n\n\n
              \/\/ formatType.cpp<\/span>\n\n#include <format><\/span>\n#include <iostream><\/span>\n\nint<\/span> main<\/span>() {\n\n    int<\/span> num{2020<\/span>};\n\n    std::<\/span>cout <<<\/span> "default:     "<\/span> <<<\/span> std::<\/span>format("{:}"<\/span>, num) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "decimal:     "<\/span> <<<\/span> std::<\/span>format("{:d}"<\/span>, num) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "binary:      "<\/span> <<<\/span> std::<\/span>format("{:b}"<\/span>, num) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "octal:       "<\/span> <<<\/span> std::<\/span>format("{:o}"<\/span>, num) <<<\/span> '\\n'<\/span>;\n    std::<\/span>cout <<<\/span> "hexadecimal: "<\/span> <<<\/span> std::<\/span>format("{:x}"<\/span>, num) <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
              \"\"<\/figure>\n\n\n\n
              What’s Next?<\/h2>\n\n\n\n
              So far, I’ve formatted basic types and strings. Additionally, you can format user-defined types. This will be the topic of my next post.<\/p>\n","protected":false},"excerpt":{"rendered":"
              In my last post, “The Formatting Library in C++20: The Format String“, I presented a few of the format specifications of the format string. Today, I finish my job. In today’s post, I will write about the width, precision, and type of the format specification. If you want to know more about the argument id, […]<\/p>\n","protected":false},"author":21,"featured_media":8964,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[454],"class_list":["post-9057","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-format"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9057","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=9057"}],"version-history":[{"count":15,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9057\/revisions"}],"predecessor-version":[{"id":9077,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9057\/revisions\/9077"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/8964"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=9057"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=9057"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=9057"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}