Namespaces
Variants

std:: format_to

From cppreference.net
C++
Text processing library
Formatting library
Standard format specification
Formatting functions
(C++20)
format_to
(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)
Definiert im 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 Ausgabeiterator out . Falls vorhanden, wird loc für lokalisierungsspezifische Formatierung verwendet.

Entspricht:

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... ) ) ; .


Lassen Sie CharT für Überladungen (1,3) char sein und wchar_t für Überladungen (2,4) .

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

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

Inhaltsverzeichnis

Parameter

out - Iterator zum Ausgabepuffer
fmt -
ein Objekt, das die Formatzeichenkette repräsentiert. Die Formatzeichenkette besteht aus
  • gewöhnlichen Zeichen (außer { und } ), die unverändert in die Ausgabe kopiert werden,
  • Escape-Sequenzen { { und } } , die in der Ausgabe durch { bzw. } ersetzt werden, und
  • Ersetzungsfeldern.

Jedes Ersetzungsfeld hat folgendes 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 für die Formatierung verwendet wird; falls weggelassen, werden die Argumente in Reihenfolge verwendet.

Die arg-id s in einer Formatzeichenkette müssen entweder alle angegeben oder alle weggelassen werden. Das Vermischen manueller und automatischer Indizierung ist ein Fehler.

format-spec - die Formatangabe, definiert durch die std::formatter -Spezialisierung für das entsprechende Argument. Darf nicht mit } beginnen.

(seit C++23)
(seit C++26)
  • Für andere formatierbare Typen wird die Formatangabe durch benutzerdefinierte formatter -Spezialisierungen bestimmt.
args... - zu formatierende Argumente
loc - std::locale für lokalisierungsabhängige Formatierung

Rückgabewert

Iterator hinter dem Ende des Ausgabebereichs.

Ausnahmen

Leitet alle Ausnahmen weiter, die durch Formatierer- oder Iterator-Operationen ausgelöst werden.

Hinweise

Es ist ein Fehler, wenn die Formatzeichenkette kein konstanter Ausdruck ist es sei denn, sie wird aus dem Ergebnis von std::runtime_format (seit C++26) initialisiert. std::vformat_to hat diese Anforderung nicht.

Beispiel

Diesen Code ausführen 
#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 kann es sein
P2216R3 C++20 wirft std::format_error für ungültige Formatzeichenfolge führt stattdessen zu Compile-Time-Fehler
P2418R2 C++20 Objekte, die weder const-verwendbar noch kopierbar sind
(wie Generator-ähnliche Objekte) sind nicht formatierbar 		Formatierung dieser Objekte erlauben
P2508R1 C++20 es gibt keinen benutzersichtigen Namen für diese Einrichtung der Name basic_format_string wird verfügbar gemacht

Siehe auch

(C++20)
speichert die formatierte Darstellung der Argumente in einem neuen String
(Funktions-Template)
(C++20)
gibt formatierte Darstellung der Argumente über einen Output-Iterator aus, ohne eine bestimmte Größe zu überschreiten
(Funktions-Template)