std:: make_format_args, std:: make_wformat_args

Retorna un objeto que almacena un array de argumentos de formato y puede convertirse implícitamente a std::basic_format_args<Context> .

El comportamiento es indefinido si typename Context :: template formatter_type < std:: remove_const_t < Ti >> no cumple con los requisitos de BasicFormatter para cualquier Ti en Args .

El programa está mal formado si para cualquier tipo Ti en Args , Ti no satisface __formattable_with < Context > .

Parámetros

Devuelve

Un objeto que contiene los argumentos de formato.

Para cada argumento t de tipo T , sea TD igual a std:: remove_const_t < std:: remove_reference_t < T >> . El correspondiente std::basic_format_arg en el resultado se determina como se indica a continuación:

• si TD es bool o Context::char_type , el std::basic_format_arg almacena t ;
• de lo contrario, si TD es char y Context::char_type es wchar_t , el std::basic_format_arg almacena static_cast < wchar_t > ( static_cast < unsigned char > ( t ) ) ;
• de lo contrario, si TD es un tipo entero con signo cuyo tamaño no es mayor que int , el std::basic_format_arg almacena static_cast < int > ( t ) ;
• de lo contrario, si TD es un tipo entero sin signo cuyo tamaño no es mayor que unsigned int , el std::basic_format_arg almacena static_cast < unsigned int > ( t ) ;
• de lo contrario, si TD es un tipo entero con signo cuyo tamaño no es mayor que long long , el std::basic_format_arg almacena static_cast < long long > ( t ) ;
• de lo contrario, si TD es un tipo entero sin signo cuyo tamaño no es mayor que unsigned long long , el std::basic_format_arg almacena static_cast < unsigned long long > ( t ) ;
• de lo contrario, si TD es float , double , o long double , el std::basic_format_arg almacena t ;
• de lo contrario, si TD es una especialización de std::basic_string_view o std::basic_string y TD::char_type es Context::char_type , el std::basic_format_arg almacena std:: basic_string_view < Context :: char_type > ( t. data ( ) , t. size ( ) ) ;
• de lo contrario, si std:: decay_t < TD > es Context :: char_type * o const Context :: char_type * , el std::basic_format_arg almacena static_cast < const Context :: char_type * > ( t ) ;
• de lo contrario, si std:: is_void_v < std:: remove_pointer_t < TD >> es true o std:: is_null_pointer_v < TD > es true , el std::basic_format_arg almacena static_cast < const void * > ( t ) ;
• de lo contrario, el std::basic_format_arg almacena un std:: basic_format_arg < Context > :: handle para t , junto con los datos adicionales necesarios para handle::format() .

Notas

Un argumento de formato tiene semántica de referencia para tipos definidos por el usuario y no extiende el tiempo de vida de args . Es responsabilidad del programador garantizar que args sobrevivan al valor de retorno. Normalmente, el resultado solo se utiliza como argumento para funciones de formato.

Ejemplo

#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)
{
    // Generar cadena de formato "{} "...
    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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también