std:: make_format_args, std:: make_wformat_args

Gibt ein Objekt zurück, das ein Array von Formatierungsargumenten speichert und implizit in std::basic_format_args<Context> konvertiert werden kann.

Das Verhalten ist undefiniert, wenn typename Context :: template formatter_type < std:: remove_const_t < Ti >> nicht den BasicFormatter -Anforderungen für irgendein Ti in Args entspricht.

Das Programm ist fehlerhaft, wenn für irgendeinen Typ Ti in Args , Ti nicht __formattable_with < Context > erfüllt.

Parameter

Rückgabewerte

Ein Objekt, das die Formatierungsargumente enthält.

Für jedes Argument t vom Typ T sei TD definiert als std:: remove_const_t < std:: remove_reference_t < T >> . Das entsprechende std::basic_format_arg im Ergebnis wird wie folgt bestimmt:

• if TD ist bool oder Context::char_type , speichert das std::basic_format_arg t ;
• andernfalls, falls TD char ist und Context::char_type wchar_t ist, speichert das std::basic_format_arg static_cast < wchar_t > ( static_cast < unsigned char > ( t ) ) ;
• andernfalls, wenn TD ein vorzeichenbehafteter Ganzzahltyp ist, dessen Größe nicht größer als int ist, speichert std::basic_format_arg static_cast < int > ( t ) ;
• andernfalls, wenn TD ein vorzeichenloser Ganzzahltyp ist, dessen Größe nicht größer als unsigned int ist, speichert std::basic_format_arg static_cast < unsigned int > ( t ) ;
• andernfalls, wenn TD ein vorzeichenbehafteter Ganzzahltyp ist, dessen Größe nicht größer als long long ist, speichert std::basic_format_arg static_cast < long long > ( t ) ;
• andernfalls, falls TD ein vorzeichenloser Ganzzahltyp ist, dessen Größe nicht größer als unsigned long long ist, speichert std::basic_format_arg static_cast < unsigned long long > ( t ) ;
• andernfalls, wenn TD float , double oder long double ist, speichert std::basic_format_arg t ;
• andernfalls, wenn TD eine std::basic_string_view - oder std::basic_string -Spezialisierung ist und TD::char_type gleich Context::char_type ist, speichert das std::basic_format_arg std:: basic_string_view < Context :: char_type > ( t. data ( ) , t. size ( ) ) ;
• andernfalls, falls std:: decay_t < TD > entweder Context :: char_type * oder const Context :: char_type * ist, speichert das std::basic_format_arg static_cast < const Context :: char_type * > ( t ) ;
• andernfalls, falls std:: is_void_v < std:: remove_pointer_t < TD >> true ist oder std:: is_null_pointer_v < TD > true ist, speichert das std::basic_format_arg static_cast < const void * > ( t ) ;
• andernfalls speichert das std::basic_format_arg ein std:: basic_format_arg < Context > :: handle für t , zusammen mit zusätzlichen Daten, die für handle::format() benötigt werden.

Hinweise

Ein Formatierungsargument hat Referenzsemantik für benutzerdefinierte Typen und verlängert nicht die Lebensdauer von args . Es liegt in der Verantwortung des Programmierers, sicherzustellen, dass args den Rückgabewert überdauern. Normalerweise wird das Ergebnis nur als Argument für Formatierungsfunktionen verwendet.

Beispiel

#include <array>
#include <format>
#include <iostream>
#include <string_view>
void raw_write_to_log(std::string_view users_fmt, std::format_args&& args)
{
    static int n{};
    std::clog << std::format("{:04} : ", n++) << std::vformat(users_fmt, args) << '\n';
}
template<typename... Args>
constexpr void log(Args&&... args)
{
    // Formatierungszeichenkette "{} "... generieren
    std::array<char, sizeof...(Args) * 3 + 1> braces{};
    constexpr const char c[4] = "{} ";
    for (auto i{0uz}; i != braces.size() - 1; ++i)
        braces[i] = c[i % 3];
    braces.back() = '\0';
    raw_write_to_log(std::string_view{braces.data()}, std::make_format_args(args...));
}
template<typename T>
const T& unmove(T&& x)
{
    return x;
}
int main()
{
    log("Number", "of", "arguments", "is", "arbitrary.");
    log("Any type that meets the BasicFormatter requirements", "can be printed.");
    log("For example:", 1, 2.0, '3', "*42*");
    raw_write_to_log("{:02} │ {} │ {} │ {}",
                     std::make_format_args(unmove(1), unmove(2.0), unmove('3'), "4"));
}

0000 : Number of arguments is arbitrary.
0001 : Any type that meets the BasicFormatter requirements can be printed.
0002 : For example: 1 2.0 3 *42*
0003 : 01 │ 2.0 │ 3 │ 4

Fehlerberichte

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

Siehe auch