std:: make_format_args, std:: make_wformat_args

Retourne un objet qui stocke un tableau d'arguments de formatage et peut être implicitement converti en std::basic_format_args<Context> .

Le comportement n'est pas défini si typename Context :: template formatter_type < std:: remove_const_t < Ti >> ne satisfait pas aux exigences du BasicFormatter pour tout Ti dans Args .

Le programme est mal formé si pour tout type Ti dans Args , Ti ne satisfait pas __formattable_with < Context > .

Paramètres

Retourne

Un objet qui contient les arguments de formatage.

Pour chaque argument t de type T , soit TD défini comme std:: remove_const_t < std:: remove_reference_t < T >> . Le std::basic_format_arg correspondant dans le résultat est déterminé comme suit :

• si TD est bool ou Context::char_type , le std::basic_format_arg stocke t ;
• sinon, si TD est char et Context::char_type est wchar_t , le std::basic_format_arg stocke static_cast < wchar_t > ( static_cast < unsigned char > ( t ) ) ;
• sinon, si TD est un type entier signé dont la taille n'est pas supérieure à int , le std::basic_format_arg stocke static_cast < int > ( t ) ;
• sinon, si TD est un type entier non signé dont la taille n'est pas supérieure à unsigned int , le std::basic_format_arg stocke static_cast < unsigned int > ( t ) ;
• sinon, si TD est un type entier signé dont la taille n'est pas supérieure à long long , le std::basic_format_arg stocke static_cast < long long > ( t ) ;
• sinon, si TD est un type entier non signé dont la taille n'est pas supérieure à unsigned long long , le std::basic_format_arg stocke static_cast < unsigned long long > ( t ) ;
• sinon, si TD est float , double , ou long double , le std::basic_format_arg stocke t ;
• sinon, si TD est une spécialisation de std::basic_string_view ou std::basic_string et que TD::char_type est Context::char_type , le std::basic_format_arg stocke std:: basic_string_view < Context :: char_type > ( t. data ( ) , t. size ( ) ) ;
• sinon, si std:: decay_t < TD > est Context :: char_type * ou const Context :: char_type * , le std::basic_format_arg stocke static_cast < const Context :: char_type * > ( t ) ;
• sinon, si std:: is_void_v < std:: remove_pointer_t < TD >> est true ou std:: is_null_pointer_v < TD > est true , le std::basic_format_arg stocke static_cast < const void * > ( t ) ;
• sinon, le std::basic_format_arg stocke un std:: basic_format_arg < Context > :: handle vers t , ainsi que les données supplémentaires nécessaires pour handle::format() .

Notes

Un argument de formatage a une sémantique de référence pour les types définis par l'utilisateur et ne prolonge pas la durée de vie de args . Il est de la responsabilité du programmeur de s'assurer que args survivent à la valeur de retour. Généralement, le résultat n'est utilisé que comme argument aux fonctions de formatage.

Exemple

#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)
{
    // Générer la chaîne de formatage "{} "...
    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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi