Namespaces
Variants

std:: print

From cppreference.net
< cpp ‎ | io
C++
Input/output library
Print functions
Print functions
print
(C++23)
(C++23)
(C++23) (C++23)
(C++23) (C++23)
Défini dans l'en-tête <print>
template < class ... Args >
void print ( std:: format_string < Args... > fmt, Args && ... args ) ;
(1) (depuis C++23)
template < class ... Args >

void print ( std:: FILE * stream,

std:: format_string < Args... > fmt, Args && ... args ) ;
(2) (depuis C++23)

Formate args selon la chaîne de format fmt , et imprime le résultat vers un flux de sortie.

1) Équivalent à std :: print ( stdout , fmt, std:: forward < Args > ( args ) ... ) .
2) Si l' encodage de littéral ordinaire est UTF-8, équivalent à ( std :: enable_nonlocking_formatter_optimization < std:: remove_cvref_t < Args >> && ... )
? std:: vprint_unicode ( stream, fmt. str , std:: make_format_args ( args... ) )
: std :: vprint_unicode_buffered ( stream, fmt. str , std:: make_format_args ( args... ) ) ; .
Sinon, équivalent à ( std :: enable_nonlocking_formatter_optimization < std:: remove_cvref_t < Args >> && ... )
? std:: vprint_nonunicode ( stream, fmt. str , std:: make_format_args ( args... ) )
: std :: vprint_nonunicode_buffered ( stream, fmt. str , std:: make_format_args ( args... ) ) ; .

Si std:: formatter < Ti, char > ne satisfait pas aux exigences BasicFormatter pour tout Ti dans Args (comme requis par std::make_format_args ), le comportement est indéfini.

Table des matières

Paramètres

stream - flux de fichier de sortie vers lequel écrire
fmt -
un objet qui représente la chaîne de format. La chaîne de format est composée de
  • caractères ordinaires (sauf { et } ), qui sont copiés inchangés vers 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  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.
args... - arguments à formater

Exceptions

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_print 202207L (C++23) Sortie formatée
202403L (C++26)
(DR23) 		Sortie formatée non tamponnée
202406L (C++26)
(DR23) 		Activation de la sortie formatée non tamponnée pour plus de types formatables
__cpp_lib_format 202207L (C++23) Exposition de std::basic_format_string

Exemple

Exécuter ce code 
#include <cstdio>
#include <filesystem>
#include <print>
int main()
{
    std::print("{2} {1}{0}!\n", 23, "C++", "Hello");  // surcharge (1)
    const auto tmp{std::filesystem::temp_directory_path() / "test.txt"};
    if (std::FILE* stream{std::fopen(tmp.c_str(), "w")})
    {
        std::print(stream, "File: {}", tmp.string()); // surcharge (2)
        std::fclose(stream);
    }
}

Sortie : 

Hello C++23!

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é
P3107R5 C++23 seules les opérations d'impression avec tampon peuvent être effectuées peut effectuer des opérations d'impression sans tampon
P3235R3 C++23 les noms des fonctions ajoutées
par P3107R5 étaient trompeurs 		a modifié les noms des fonctions

Voir aussi

(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)
affiche une représentation formatée des arguments
(modèle de fonction)
(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++11)
imprime une sortie formatée vers stdout , un flux de fichier ou un tampon
(fonction)