Formatting library (since C++20)
La bibliothèque de formatage de texte offre une alternative sûre et extensible à la famille de fonctions printf. Elle est destinée à compléter la bibliothèque de flux d'E/S C++ existante.
Table des matières |
Spécifications de format
La spécification de format définit comment les objets sont formatés avec différents types d'options.
Le formatage des objets de types de base et des types de chaîne standard utilise la spécification de format de base . D'autres composants de la bibliothèque peuvent également fournir leurs propres spécifications de format, voir ici pour plus de détails.
Fonctions de formatage
|
Défini dans l'en-tête
<format>
|
|
|
(C++20)
|
stocke la représentation formatée des arguments dans une nouvelle chaîne
(modèle de fonction) |
|
(C++20)
|
écrit la représentation formatée de ses arguments via un itérateur de sortie
(modèle de fonction) |
|
(C++20)
|
écrit la représentation formatée de ses arguments via un itérateur de sortie, sans dépasser la taille spécifiée
(modèle de fonction) |
|
(C++20)
|
détermine le nombre de caractères nécessaires pour stocker la représentation formatée de ses arguments
(modèle de fonction) |
Chaînes de format
|
Défini dans l'en-tête
<format>
|
|
|
(C++20)
(C++20)
(C++20)
|
classe template qui effectue des vérifications de chaîne de format à la compilation lors de la construction
(classe template) |
|
(C++26)
|
crée des chaînes de format à l'exécution directement utilisables dans les fonctions de formatage orientées utilisateur
(fonction) |
Concepts de formatage
|
Défini dans l'en-tête
<format>
|
|
|
(C++23)
|
spécifie qu'un type est formattable, c'est-à-dire qu'il spécialise
std::formatter
et fournit les fonctions membres
parse
et
format
(concept) |
Support d'extensibilité et détail d'implémentation
|
Défini dans l'en-tête
<format>
|
|
|
(C++20)
|
variante non template de
std::format
utilisant une représentation d'arguments à effacement de type
(fonction) |
|
(C++20)
|
variante non template de
std::format_to
utilisant une représentation d'arguments à effacement de type
(fonction template) |
|
(C++20)
(C++20)
|
crée un objet à effacement de type référençant tous les arguments de formatage, convertible en
format_args
(fonction template) |
|
(C++20)
(obsolète en C++26)
|
interface de visite d'arguments pour les formateurs personnalisés
(fonction template) |
|
(C++20)
|
définit les règles de formatage pour un type donné
(classe template) |
|
(C++23)
|
classe template qui aide à implémenter les spécialisations de
std::formatter
pour les types de plages
(classe template) |
|
indique que le type d'argument peut être imprimé efficacement
(variable template) |
|
|
(C++23)
|
spécifie comment une plage doit être formatée
(énumération) |
|
(C++23)
|
sélectionne un
std::range_format
adapté pour une plage
(variable template) |
|
(C++20)
|
classe template qui fournit l'accès à un argument de formatage pour les formateurs personnalisés
(classe template) |
|
(C++20)
(C++20)
(C++20)
|
classe qui fournit l'accès à tous les arguments de formatage
(classe template) |
|
(C++20)
(C++20)
(C++20)
|
état de formatage, incluant tous les arguments de formatage et l'itérateur de sortie
(classe template) |
|
(C++20)
(C++20)
(C++20)
|
état du parseur de chaîne de formatage
(classe template) |
|
(C++20)
|
type d'exception levée lors d'erreurs de formatage
(classe) |
Éléments d'assistance (depuis C++23)
|
template
<
class
R,
class
CharT
>
concept
/*const-formattable-range*/
=
|
(1) | ( exposition uniquement* ) |
|
template
<
class
R,
class
CharT
>
using
/*fmt-maybe-const*/
=
|
(2) | ( exposition uniquement* ) |
Notes
| Macro de test de fonctionnalité | Valeur | Std | Fonctionnalité | |
|---|---|---|---|---|
__cpp_lib_format
|
201907L
|
(C++20) | Formatage de texte | |
202106L
|
(C++23)
(DR20) |
Vérifications de chaîne de format à la compilation ;
Réduction de la paramétrisation de std::vformat_to |
||
202110L
|
(C++23)
(DR20) |
Correction de la gestion des locales dans les formateurs chrono ;
Prise en charge des types non const-formattables |
||
202207L
|
(C++23)
(DR20) |
Exposition de
std::basic_format_string
;
Clarification de la gestion des encodages dans le formatage localisé des types chrono |
||
202304L
|
(C++26) | Formatage des pointeurs | ||
202305L
|
(C++26) | Vérification de type des arguments de format | ||
202306L
|
(C++26) |
Membre
std::basic_format_arg::visit
|
||
202311L
|
(C++26) | Chaîne de format à l'exécution | ||
202403L
|
(C++26) | Impression de lignes vides avec std::println | ||
202403L
|
(C++26)
(DR23) |
Permettre une implémentation efficace de
std::print
|
||
__cpp_lib_format_ranges
|
202207L
|
(C++23) | Formatage des plages | |
__cpp_lib_format_path
|
202403L
|
(C++26) | Formatage de std::filesystem::path | |
__cpp_lib_format_uchar
|
202311L
|
(C++26) | Correction du formatage des unités de code comme entiers | |
__cpp_lib_formatters
|
202302L
|
(C++23) | Formatage de std::thread::id et std::stacktrace |
Nous traitons intentionnellement l'ajout de
std::basic_format_string
(
P2508
) comme un rapport de défaut car toutes les implémentations connues rendent ces composants disponibles en mode C++20, bien que cela ne soit pas officiellement catégorisé ainsi.
Exemple
#include <cassert> #include <format> int main() { std::string message = std::format("The answer is {}.", 42); assert(message == "The answer is 42."); }
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 | Applicable à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| P2418R2 | C++20 |
les objets qui ne sont ni formatables de manière constante ni copiables
(tels que les objets de type générateur) ne sont pas formatables |
permettre le formatage de ces objets
(exigences de formateur assouplies) |
| P2508R1 | C++20 | il n'y a pas de nom visible par l'utilisateur pour cette fonctionnalité |
le nom
basic_format_string
est exposé
|
Voir aussi
|
(C++23)
|
imprime vers
stdout
ou un flux de fichier en utilisant la représentation
formatée
des arguments
(modèle de fonction) |
|
(C++23)
|
identique à
std::print
sauf que chaque impression est terminée par un saut de ligne supplémentaire
(modèle de fonction) |
|
(C++23)
|
produit la représentation
formatée
des arguments
(modèle de fonction) |