Namespaces
Variants
    Actions

      std::format

      From cppreference.com
      < cpp‎ | utility‎ | format
       
      C++
       
      Text processing library
       
      Formatting library
      Standard format specification
      Formatting functions
      format
      (C++20)
      (C++20)
      (C++20)
      (C++20)
      (C++20)
      (C++20)
      Format strings
      (C++20)(C++20)(C++20)
      (C++26)
      Formatting concepts
      (C++23)
      Formatter
      (C++20)
      (C++23)
      (C++23)
      (C++23)
      (C++23)
      (C++20)(C++20)(C++20)
      (C++20)(C++20)(C++20)
      (C++23)
      (C++23)
      Formatting arguments
      (C++20)
      (C++20)
      (C++20)(C++20)(C++20)
      (C++20)(deprecated in C++26)
      (C++20)(C++20)
      Format error
      (C++20)
       
      Defined in header <format>
      template<class... Args>
      std::string format(std::format_string<Args...> fmt, Args&&... args);
      		 (1) (since C++20)
      template<class... Args>
      std::wstring format(std::wformat_string<Args...> fmt, Args&&... args);
      		 (2) (since C++20)
      template<class... Args>

      std::string format(conststd::locale& loc,

                          std::format_string<Args...> fmt, Args&&... args);
      		 (3) (since C++20)
      template<class... Args>

      std::wstring format(conststd::locale& loc,

                           std::wformat_string<Args...> fmt, Args&&... args);
      		 (4) (since C++20)

      Format args according to the format string fmt, and return the result as a string. If present, loc is used for locale-specific formatting.

      1) Equivalent to returnstd::vformat(fmt.get(), std::make_format_args(args...));.
      2) Equivalent to returnstd::vformat(fmt.get(), std::make_wformat_args(args...));.
      3) Equivalent to returnstd::vformat(loc, fmt.get(), std::make_format_args(args...));.
      4) Equivalent to returnstd::vformat(loc, fmt.get(), std::make_wformat_args(args...));.

      Since P2216R3, std::format does a compile-time check on the format string (via the helper type std::format_string or std::wformat_string). If it is found to be invalid for the types of the arguments to be formatted, a compilation error will be emitted. If the format string cannot be a compile-time constant, or the compile-time check needs to be avoided, use std::vformator std::runtime_format on fmt(since C++26) instead.

      The following requirements apply to each type T in Args, where CharT is char for overloads (1,3), wchar_t for overloads (2,4):

      Contents

      [edit]Parameters

      fmt -
      [edit]
      an object that represents the format string. The format string consists of
      • ordinary characters (except { and }), which are copied unchanged to the output,
      • escape sequences {{ and }}, which are replaced with { and } respectively in the output, and
      • replacement fields.

      Each replacement field has the following format:

      {arg-id(optional)} (1)
      {arg-id(optional):format-spec} (2)
      1) replacement field without a format specification
      2) replacement field with a format specification
      arg-id - specifies the index of the argument in args whose value is to be used for formatting; if it is omitted, the arguments are used in order.

      The arg-id s in a format string must all be present or all be omitted. Mixing manual and automatic indexing is an error.

      format-spec - the format specification defined by the std::formatter specialization for the corresponding argument. Cannot start with }.

      (since C++23)
      (since C++26)
      • For other formattable types, the format specification is determined by user-defined formatter specializations.
      args... - arguments to be formatted
      loc - std::locale used for locale-specific formatting

      [edit]Return value

      A string object holding the formatted result.

      [edit]Exceptions

      Throws std::bad_alloc on allocation failure. Also propagates exception thrown by any formatter.

      [edit]Notes

      It is not an error to provide more arguments than the format string requires: 

      std::format("{} {}!", "Hello", "world", "something");// OK, produces "Hello world!"

      As of P2216R3, it is an error if the format string is not a constant expression. std::vformat can be used in this case. 

      std::string f(std::string_view runtime_format_string){// return std::format(runtime_format_string, "foo", "bar"); // errorreturnstd::vformat(runtime_format_string, std::make_format_args("foo", "bar"));// OK}

      std::runtime_format can be used directly on std::format instead of std::vformat which requires std::basic_format_args as an argument. 

      std::string f(std::string_view runtime_format_string){return std::format(std::runtime_format(runtime_format_string), "foo", "bar");}


      		(since C++26)

      [edit]Example

      Run this code
      #include <format>#include <iostream>#include <string>#include <string_view>   template<typename... Args>std::string dyna_print(std::string_view rt_fmt_str, Args&&... args){returnstd::vformat(rt_fmt_str, std::make_format_args(args...));}   int main(){std::cout<< std::format("Hello {}!\n", "world");   std::string fmt;for(int i{}; i !=3;++i){ fmt +="{} ";// constructs the formatting stringstd::cout<< fmt <<" : ";std::cout<< dyna_print(fmt, "alpha", 'Z', 3.14, "unused");std::cout<<'\n';}}

      Output: 

      Hello world! {}  : alpha {} {}  : alpha Z {} {} {}  : alpha Z 3.14

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DR Applied to Behavior as published Correct behavior
      P2216R3C++20 throws std::format_error for invalid format string invalid format string results in compile-time error
      P2418R2C++20 objects that are neither const-usable nor copyable
      (such as generator-like objects) are not formattable       		allow formatting these objects
      P2508R1C++20 there's no user-visible name for this facility the name basic_format_string is exposed

      [edit]See also

      (C++20)
      		 writes out formatted representation of its arguments through an output iterator
      (function template)[edit]
      (C++20)
      		 writes out formatted representation of its arguments through an output iterator, not exceeding specified size
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/format/format&oldid=171996"
      close