Namespaces
Variants

std:: println

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

void println ( std:: FILE * stream,

std:: format_string < Args... > fmt, Args && ... args ) ;
(2) (depuis C++23)
void println ( ) ;
(3) (depuis C++26)
void println ( std:: FILE * stream ) ;
(4) (depuis C++26)

Formatez args selon la chaîne de format fmt avec un ' \n ' ajouté (ce qui signifie que chaque sortie se termine par une nouvelle ligne), et imprimez le résultat vers un flux.

1) Équivalent à std :: println ( stdout , fmt, std:: forward < Args > ( args ) ... ) .
2) Équivalent à effectuer les opérations suivantes :

std:: print ( stream, "{} \n " , std:: format ( fmt, std:: forward < Args > ( args ) ... ) ) ;

(jusqu'à C++26)

std:: print ( stream, std:: runtime_format ( std:: string ( fmt. get ( ) ) + ' \n ' ) ,
std:: forward < Args > ( args ) ... )

(depuis C++26)
3) Équivalent à std :: println ( stdout ) .
4) Équivalent à std:: print ( stream, " \n " ) .

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 constitué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 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.
args... - arguments à formater

Exceptions

Notes

Bien que les surcharges ( 3,4 ) soient ajoutées en C++26, toutes les implémentations connues les rendent disponibles en mode C++23.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_print 202207L (C++23) Sortie formatée
202403L (C++26) Sortie formatée non tamponnée [1]
__cpp_lib_format 202207L (C++23) Exposition de std::basic_format_string
  1. ↑ Bien que P3107R5 soit accepté comme DR, std::runtime_format n'est disponible qu'à partir de C++26. Par conséquent, la résolution ne peut pas être appliquée en C++23.

Exemple

Exécuter ce code 
#include <print>
int main()
{
    // Chaque appel à std::println se termine par un saut de ligne
    std::println("Please"); // surcharge (1)
    std::println("enter"); // (1)
    std::print("pass");
    std::print("word");
    std::println(); // (3); valide depuis C++26; même effet que std::print("\n"); 
}

Sortie : 

Please
enter
password

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)
affiche la représentation formatée des arguments avec un ' \n ' ajouté
(modèle de fonction)
(C++20)
stocke la représentation formatée des arguments dans une nouvelle chaîne
(modèle de fonction)
(C++11)
imprime une sortie formatée vers stdout , un flux de fichier ou un tampon
(fonction)