std::format_to

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Text processing library

Localization library

Regular expressions library(C++11)

Formatting library(C++20)

Null-terminated sequence utilities

Byte strings

Multibyte strings

Wide strings

Primitive numeric conversions

to_chars (C++17)
to_chars_result (C++17)
from_chars (C++17)
from_chars_result (C++17)
chars_format (C++17)

Text encoding identifications

text_encoding

(C++26)

[edit]

Formatting library

Standard format specification
Formatting functions
format (C++20)
format_to (C++20)
format_to_n (C++20)
formatted_size (C++20)
vformat (C++20)
vformat_to (C++20)
Format strings
basic_format_stringformat_stringwformat_string (C++20)(C++20)(C++20)
runtime_format (C++26)
Formatting concepts
formattable (C++23)
Formatter
formatter (C++20)
formatter<pair-or-tuple> (C++23)
formatter<range> (C++23)
range_formatter (C++23)
enable_nonlocking_formatter_optimization (C++23)
basic_format_parse_contextformat_parse_contextwformat_parse_context (C++20)(C++20)(C++20)
basic_format_contextformat_contextwformat_context (C++20)(C++20)(C++20)
range_format (C++23)
format_kind (C++23)
Formatting arguments
basic_format_arg (C++20)
basic_format_arg::handle (C++20)
basic_format_argsformat_argswformat_args (C++20)(C++20)(C++20)
visit_format_arg (C++20)(deprecated in C++26)
make_format_argsmake_wformat_args (C++20)(C++20)
Format error
format_error (C++20)

[edit]

Defined in header`<format>`
template<class OutputIt,class...Args> OutputIt format_to( OutputIt out, std::format_string<Args...> fmt, Args&&...args);	(1)	(since C++20)
template<class OutputIt,class...Args> OutputIt format_to( OutputIt out, std::wformat_string<Args...> fmt, Args&&...args);	(2)	(since C++20)
template<class OutputIt,class...Args> OutputIt format_to( OutputIt out,conststd::locale& loc, std::format_string<Args...> fmt, Args&&...args);	(3)	(since C++20)
template<class OutputIt,class...Args> OutputIt format_to( OutputIt out,conststd::locale& loc, std::wformat_string<Args...> fmt, Args&&...args);	(4)	(since C++20)

Formatargs according to the format stringfmt, and write the result to the output iteratorout. If present,loc is used for locale-specific formatting.

Equivalent to:

1)returnstd::vformat_to(std::move(out), fmt.str,std::make_format_args(args...));

2)returnstd::vformat_to(std::move(out), fmt.str,std::make_wformat_args(args...));

3)returnstd::vformat_to(std::move(out), loc, fmt.str,std::make_format_args(args...));

4)returnstd::vformat_to(std::move(out), loc, fmt.str,std::make_wformat_args(args...));.

LetCharT bechar for overloads(1,3),wchar_t for overloads(2,4).

These overloads participate in overload resolution only ifOutputIt satisfies the conceptstd::output_iterator<const CharT&>.

If any of the following conditions is satisfied, the behavior is undefined:

OutputIt does not modelstd::output_iterator<const CharT&>.
std::formatter<Ti, CharT> does not meet theBasicFormatter requirements (as required bystd::make_format_args andstd::make_wformat_args) for someTi inArgs.

[edit]Parameters

out - iterator to the output buffer

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. Thearg-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 thestd::formatter specialization for the corresponding argument. Cannot start with}.

For basic types and standard string types, the format specification is interpreted asstandard format specification.
For chrono types, the format specification is interpreted aschrono format specification.

For range types, the format specification is interpreted asrange format specification.
Forstd::pair andstd::tuple, the format specification is interpreted astuple format specification.
Forstd::thread::id andstd::stacktrace_entry, seethread id format specification andstacktrace entry format specification.
Forstd::basic_stacktrace, no format specifier is allowed.

(since C++23)

Forstd::filesystem::path, seepath format specification.

(since C++26)

For other formattable types, the format specification is determined by user-definedformatter specializations.

args... - arguments to be formatted

loc - std::locale used for locale-specific formatting

[edit]Return value

Iterator past the end of the output range.

[edit]Exceptions

Propagates any exception thrown by formatter or iterator operations.

[edit]Notes

It is an error if the format string is not a constant expression unless it is initialized from the result ofstd::runtime_format(since C++26).std::vformat_to does not have this requirement.

[edit]Example

Run this code

#include <format>#include <iostream>#include <iterator>#include <string> int main(){std::string buffer;     std::format_to(std::back_inserter(buffer),// < OutputIt"Hello, C++{}!\n",// < fmt"20"// < arg);std::cout<< buffer;    buffer.clear();     std::format_to(std::back_inserter(buffer),// < OutputIt"Hello, {0}::{1}!{2}",// < fmt"std",// < arg {0}"format_to()",// < arg {1}"\n",// < arg {2}"extra param(s)..."// < unused);std::cout<< buffer<<std::flush; std::wstring wbuffer;    std::format_to(std::back_inserter(wbuffer),// < OutputIt        L"Hello, {2}::{1}!{0}",// < fmt        L"\n",// < arg {0}        L"format_to()",// < arg {1}        L"std",// < arg {2}        L"...is not..."// < unused        L"...an error!"// < unused);std::wcout<< wbuffer;}

Output:

Hello, C++20!Hello, std::format_to()!Hello, std::format_to()!

[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
LWG 3539	C++20	out could not be a move-only iterator	it can be
P2216R3	C++20	throwsstd::format_error for invalid format string	results in compile-time error instead
P2418R2	C++20	objects that are neither const-usable nor copyable (such as generator-like objects) are not formattable	allow formatting these objects
P2508R1	C++20	there's no user-visible name for this facility	the name`basic_format_string` is exposed

[edit]See also

format (C++20)	stores formatted representation of the arguments in a new string (function template)[edit]
format_to_n (C++20)	writes out formatted representation of its arguments through an output iterator, not exceeding specified size (function template)[edit]