std::format_to

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Textverarbeitungsbibliothek

Lokalisierungsbibliothek

Reguläre Ausdrücke-Bibliothek (C++11)

Formatierungsbibliothek (C++20)

Dienstprogramme für Null-terminierte Sequenzen

Byte-Zeichenketten

Multibyte-Zeichenketten

Wide-Zeichenketten

Primitive numerische Konvertierungen

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

Textkodierungserkennung

text_encoding (C++26)

 

Formatierungsbibliothek

Standardformat-Spezifikation

Formatierungsfunktionen

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)

Formatierungs-Konzepte

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)

Formatierungs-Argumente

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) (veraltet in C++26)

make_format_argsmake_wformat_args (C++20)(C++20)

Format-Fehler

format_error (C++20)

 

Definiert in Header <format>
template< class OutputIt, class... Args > OutputIt format_to( OutputIt out,                     std::format_string<Args...> fmt, Args&&... args );	(1)	(seit C++20)
template< class OutputIt, class... Args > OutputIt format_to( OutputIt out,                     std::wformat_string<Args...> fmt, Args&&... args );	(2)	(seit C++20)
template< class OutputIt, class... Args > OutputIt format_to( OutputIt out, const std::locale& loc,                     std::format_string<Args...> fmt, Args&&... args );	(3)	(seit C++20)
template< class OutputIt, class... Args > OutputIt format_to( OutputIt out, const std::locale& loc,                     std::wformat_string<Args...> fmt, Args&&... args );	(4)	(seit C++20)

Formatiere args gemäß der Formatzeichenkette fmt und schreibe das Ergebnis in den Ausgabiterator out. Wenn vorhanden, wird loc für die lokalabhängige Formatierung verwendet.

Äquivalent zu

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

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

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

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

Sei CharT char für die Überladungen (1,3) und wchar_t für die Überladungen (2,4).

Diese Überladungen nehmen nur an der Überladungsauflösung teil, wenn OutputIt das Konzept std::output_iterator<const CharT&> erfüllt.

Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert

• OutputIt modelliert nicht std::output_iterator<const CharT&>.
• std::formatter<Ti, CharT> erfüllt die Anforderungen an BasicFormatter (wie von std::make_format_args und std::make_wformat_args gefordert) für einige Ti in Args nicht.

Parameter

out	-	Iterator auf den Ausgabepuffer
fmt	-	ein Objekt, das den Formatstring repräsentiert. Der Formatstring besteht aus regulären Zeichen (außer { und }), die unverändert in die Ausgabe kopiert werden, Escape-Sequenzen {{ und }}, die in der Ausgabe durch { und } ersetzt werden, und Ersetzungsfeldern. Jedes Ersetzungsfeld hat das folgende Format: { arg-id (optional) } (1) { arg-id (optional) : format-spec } (2) 1) Ersetzungsfeld ohne Formatangabe 2) Ersetzungsfeld mit Formatangabe arg-id - gibt den Index des Arguments in `args` an, dessen Wert zur Formatierung verwendet werden soll; wenn er weggelassen wird, werden die Argumente in der Reihenfolge verwendet. Die `arg-id`s in einem Formatstring müssen entweder alle vorhanden sein oder alle weggelassen werden. Das Mischen von manueller und automatischer Indizierung ist ein Fehler. format-spec - die Formatangabe, die durch die std::formatter-Spezialisierung für das entsprechende Argument definiert ist. Kann nicht mit } beginnen. Für Basistypen und Standard-Stringtypen wird die Formatangabe als Standard-Formatangabe interpretiert. Für Chrono-Typen wird die Formatangabe als Chrono-Formatangabe interpretiert. Für Bereichstypen wird die Formatangabe als Bereichsformatangabe interpretiert. Für std::pair und std::tuple wird die Formatangabe als Tupel-Formatangabe interpretiert. Für std::thread::id und std::stacktrace_entry siehe Thread-ID-Formatangabe und Stacktrace-Eintrags-Formatangabe. Für std::basic_stacktrace ist keine Formatierungsangabe erlaubt. (seit C++23) Für std::filesystem::path siehe Pfad-Formatangabe. (seit C++26) Für andere formatierbare Typen wird die Formatangabe durch benutzerspezifische formatter-Spezialisierungen bestimmt.
args...	-	zu formatierende Argumente
loc	-	std::locale, die für die lokale-spezifische Formatierung verwendet wird.

Rückgabewert

Iterator hinter das Ende des Ausgabebereichs.

Ausnahmen

Gibt alle Ausnahmen weiter, die von Formatierer- oder Iteratoroperationen ausgelöst werden.

Anmerkungen

Gemäß P2216R3 ist es ein Fehler, wenn die Formatzeichenkette kein konstantes Ausdruck ist. std::vformat_to oder std::runtime_format(seit C++26) kann in diesem Fall verwendet werden.

Beispiel

Führen Sie diesen Code aus

#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;
}

Ausgabe

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

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 3539	C++20	out konnte kein Move-only-Iterator sein	er kann es sein
P2216R3	C++20	wirft std::format_error für ungültige Formatzeichenkette.	führt stattdessen zu einem Compile-Zeitfehler
P2418R2	C++20	Objekte, die weder const-benutzbar noch kopierbar sind. (wie Generator-ähnliche Objekte) sind nicht formatierbar	Ermöglichen der Formatierung dieser Objekte
P2508R1	C++20	Es gibt keinen benutzerseitig sichtbaren Namen für diese Einrichtung	Der Name basic_format_string wird verfügbar gemacht

Siehe auch

format (C++20)	speichert die formatierte Darstellung der Argumente in einem neuen String (Funktionstemplate)
format_to_n (C++20)	schreibt die formatierte Darstellung ihrer Argumente über einen Output-Iterator, überschreitet nicht die angegebene Größe (Funktionstemplate)