Namespaces
Variants

std:: basic_format_string, std:: format_string, std:: wformat_string

From cppreference.net
C++
Text processing library
Formatting library
Standard format specification
Formatting functions
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
Format strings
basic_format_string format_string wformat_string
(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)
Défini dans l'en-tête <format>
template < class CharT, class ... Args >
struct basic_format_string ;
(1) (depuis C++20)
template < class ... Args >

using format_string =

basic_format_string < char , std:: type_identity_t < Args > ... > ;
(2) (depuis C++20)
template < class ... Args >

using wformat_string =

basic_format_string < wchar_t , std:: type_identity_t < Args > ... > ;
(3) (depuis C++20)

Le modèle de classe std::basic_format_string encapsule une std::basic_string_view qui sera utilisée par les fonctions de formatage.

Le constructeur de std::basic_format_string effectue des vérifications de chaîne de format à la compilation sauf si l'argument du constructeur est retourné par std::runtime_format (depuis C++26) .

Table des matières

Fonctions membres

(constructeur)
construit un basic_format_string , générant une erreur de compilation si l'argument n'est pas une chaîne de format
(fonction membre publique)
get
retourne la chaîne encapsulée
(fonction membre publique)

std::basic_format_string:: basic_format_string

template < class T >
consteval basic_format_string ( const T & s ) ;
(1)
basic_format_string ( /* runtime-format-string */ < CharT > s ) noexcept ;
(2) (depuis C++26)
1) Construit un objet basic_format_string qui stocke une vue de la chaîne s . Si l'argument n'est pas une constante à la compilation, ou s'il ne peut pas être analysé comme une chaîne de format pour les types d'arguments de formatage Args , la construction est mal formée.
Cette surcharge participe à la résolution de surcharge seulement si const T & modélise std:: convertible_to < std:: basic_string_view < CharT >> .
2) Construit un objet basic_format_string qui stocke une vue de la chaîne s telle que retournée par std::runtime_format . Il n'effectue pas de vérifications du format de chaîne lors de la construction.

Paramètres

s - un objet qui représente la chaîne de format. La chaîne de format est constituée de
  • caractères ordinaires (sauf { et } ), qui sont copiés inchangés dans la sortie,
  • séquences d'échappement { { et } } , qui sont remplacées respectivement par { et } dans la sortie, et
  • champs de remplacement.

Chaque champ de remplacement a le format suivant :

{ arg-id (optionnel) } (1)
{ arg-id (optionnel) : format-spec } (2)
1) champ de remplacement sans spécification de format
2) champ de remplacement avec spécification de format
arg-id - spécifie l'index de l'argument dans args dont la valeur doit être utilisée pour le formatage ; s'il est omis, les arguments sont utilisés dans l'ordre.

Les arg-id s dans une chaîne de format doivent tous être présents ou tous être omis. Mélanger l'indexation manuelle et automatique est une erreur.

format-spec - la spécification de format définie par la spécialisation std::formatter pour l'argument correspondant. Ne peut pas commencer par } .

(depuis C++23)
(depuis C++26)
  • Pour les autres types formatables, la spécification de format est déterminée par les spécialisations formatter définies par l'utilisateur.

std::basic_format_string:: get

constexpr std:: basic_string_view < CharT > get ( ) const noexcept ;

Retourne la vue de chaîne stockée.

Notes

Les modèles d'alias format_string et wformat_string utilisent std::type_identity_t pour inhiber la déduction des arguments de modèle. Généralement, lorsqu'ils apparaissent comme paramètre de fonction, leurs arguments de modèle sont déduits d'autres arguments de fonction. 

template<class... Args>
std::string format(std::format_string<Args...> fmt, Args&&... args);
auto s = format("{} {}", 1.0, 2);
// Appelle format<double, int>. Args sont déduits de 1.0, 2
// En raison de l'utilisation de type_identity_t dans format_string, la déduction d'arguments template
// ne prend pas en compte le type de la chaîne de format.

Exemple

Cette section est incomplète
Raison : aucun exemple

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.

DR Appliqué à Comportement publié Comportement corrigé
P2508R1 C++20 il n'existe pas de nom visible par l'utilisateur pour cette fonctionnalité le nom basic_format_string est exposé