Namespaces
Variants

std:: printf, std:: fprintf, std:: sprintf, std:: snprintf

From cppreference.net
< cpp ‎ | io ‎ | c
C++
Input/output library
C-style I/O
Défini dans l'en-tête <cstdio>
int printf ( const char * format, ... ) ;
(1)
int fprintf ( std:: FILE * stream, const char * format, ... ) ;
(2)
int sprintf ( char * buffer, const char * format, ... ) ;
(3)
int snprintf ( char * buffer, std:: size_t buf_size, const char * format, ... ) ;
(4) (depuis C++11)

Charge les données des emplacements donnés, les convertit en équivalents de chaîne de caractères et écrit les résultats vers divers récepteurs.

1) Écrit les résultats vers stdout .
2) Écrit les résultats dans un flux de fichier stream .
3) Écrit les résultats dans une chaîne de caractères buffer .
4) Écrit les résultats dans une chaîne de caractères buffer . Au maximum buf_size - 1 caractères sont écrits. La chaîne de caractères résultante sera terminée par un caractère nul, sauf si buf_size est zéro. Si buf_size est zéro, rien n'est écrit et buffer peut être un pointeur nul, cependant la valeur de retour (nombre d'octets qui seraient écrits sans inclure le terminateur nul) est toujours calculée et renvoyée.

Si un appel à sprintf ou snprintf provoque une copie entre des objets qui se chevauchent, le comportement est indéfini (par exemple sprintf ( buf, "%s text" , buf ) ; ).

Table des matières

Paramètres

stream - flux de fichier de sortie vers lequel écrire
buffer - pointeur vers une chaîne de caractères à écrire
buf_size - jusqu'à buf_size - 1 caractères peuvent être écrits, plus le terminateur nul
format - pointeur vers une chaîne multioctets terminée par un nul spécifiant comment interpréter les données
... - arguments spécifiant les données à imprimer. Si un argument après promotions d'arguments par défaut n'est pas du type attendu par la spécification de conversion correspondante (le type attendu est le type promu ou un type compatible du type promu), ou s'il y a moins d'arguments que requis par format , le comportement est indéfini. S'il y a plus d'arguments que requis par format , les arguments superflus sont évalués et ignorés

La chaîne de format est composée de caractères octets ordinaires (sauf % ), qui sont copiés inchangés dans le flux de sortie, et de spécifications de conversion. Chaque spécification de conversion a le format suivant :

  • introduction % caractère.
  • (optionnel) un ou plusieurs drapeaux qui modifient le comportement de la conversion :
  • - : le résultat de la conversion est justifié à gauche dans le champ (par défaut il est justifié à droite).
  • + : le signe des conversions signées est toujours ajouté au début du résultat de la conversion (par défaut le résultat est précédé d'un moins uniquement lorsqu'il est négatif).
  • espace : si le résultat d'une conversion signée ne commence pas par un caractère de signe, ou est vide, un espace est ajouté au début du résultat. Il est ignoré si le drapeau + est présent.
  • # : la forme alternative de la conversion est effectuée. Voir le tableau ci-dessous pour les effets exacts, sinon le comportement est indéfini.
  • 0 : pour les conversions de nombres entiers et à virgule flottante, des zéros non significatifs sont utilisés pour remplir le champ au lieu des caractères espace . Pour les nombres entiers, il est ignoré si la précision est explicitement spécifiée. Pour d'autres conversions, l'utilisation de ce drapeau entraîne un comportement indéfini. Il est ignoré si le drapeau - est présent.
  • (optionnel) valeur entière ou * qui spécifie la largeur minimale du champ. Le résultat est complété avec des caractères espace (par défaut), si nécessaire, à gauche lors d'un alignement à droite, ou à droite lors d'un alignement à gauche. Dans le cas où * est utilisé, la largeur est spécifiée par un argument supplémentaire de type int , qui apparaît avant l'argument à convertir et l'argument fournissant la précision si celui-ci est fourni. Si la valeur de l'argument est négative, cela entraîne l'activation du drapeau - et une largeur de champ positive (Note : Ceci est la largeur minimale : La valeur n'est jamais tronquée.).
  • (optionnel) . suivi d'un nombre entier ou * , ou ni l'un ni l'autre, qui spécifie la précision de la conversion. Dans le cas où * est utilisé, la précision est spécifiée par un argument supplémentaire de type int , qui apparaît avant l'argument à convertir, mais après l'argument fournissant la largeur minimale du champ si celui-ci est fourni. Si la valeur de cet argument est négative, elle est ignorée. Si ni un nombre ni * n'est utilisé, la précision est prise comme zéro. Voir le tableau ci-dessous pour les effets exacts de la précision .
  • (optionnel) modificateur de longueur qui spécifie la taille de l'argument (en combinaison avec le spécificateur de format de conversion, il spécifie le type de l'argument correspondant).
  • spécificateur de format de conversion.

Les spécificateurs de format suivants sont disponibles :

Spécificateur
de Conversion 		Explication Type d'Argument
Attendu
Modificateur de longueur→ hh h aucun l ll j z t L
Disponible uniquement depuis C++11→ Oui Oui Oui Oui Oui
% Écrit le caractère littéral % . La spécification de conversion complète doit être %% . N/A N/A N/A N/A N/A N/A N/A N/A N/A
c

Écrit un caractère unique .

  • L'argument est d'abord converti en unsigned char .
  • Si le modificateur l est utilisé, l'argument est d'abord converti en chaîne de caractères comme avec %ls avec un argument wchar_t [ 2 ] .
N/A N/A
int
std::wint_t
N/A N/A N/A N/A N/A
s

Écrit une chaîne de caractères .

  • L'argument doit être un pointeur vers le premier élément d'un tableau de caractères.
  • Precision spécifie le nombre maximum d'octets à écrire. Si Precision n'est pas spécifiée, écrit chaque octet jusqu'au premier terminateur nul (non inclus).
  • Si le spécificateur l est utilisé, l'argument doit être un pointeur vers le premier élément d'un tableau de wchar_t , qui est converti en tableau de caractères comme par un appel à std::wcrtomb avec un état de conversion initialisé à zéro.
N/A N/A
char *
wchar_t *
N/A N/A N/A N/A N/A
d
i

Convertit un entier signé en représentation décimale [-]dddd .

  • Précision spécifie le nombre minimum de chiffres à afficher. La précision par défaut est 1 .
  • Si la valeur convertie et la précision sont toutes deux ​ 0 ​ , la conversion ne produit aucun caractère.
  • Pour le modificateur z , le type d'argument attendu est la version signée de std::size_t .
signed char
short
int
long
long long
※
N/A
o

Convertit un entier non signé en représentation octale oooo .

  • Précision spécifie le nombre minimum de chiffres à afficher. La précision par défaut est 1 .
  • Si la valeur convertie et la précision sont toutes deux ​ 0 ​ , la conversion ne produit aucun caractère.
  • Dans l' implémentation alternative , la précision est augmentée si nécessaire pour écrire un zéro initial. Dans ce cas, si la valeur convertie et la précision sont toutes deux ​ 0 ​ , un seul ​ 0 ​ est écrit.
unsigned char
unsigned short
unsigned int
unsigned long
unsigned long long
version non signée de std::ptrdiff_t
N/A
x
X

Convertit un entier non signé en représentation hexadécimale hhhh .

  • Pour la conversion x les lettres abcdef sont utilisées.
  • Pour la conversion X les lettres ABCDEF sont utilisées.
  • Précision spécifie le nombre minimum de chiffres à afficher. La précision par défaut est 1 .
  • Si la valeur convertie et la précision sont toutes deux ​ 0 ​ la conversion ne produit aucun caractère.
  • Dans l' implémentation alternative 0x ou 0X est préfixé aux résultats si la valeur convertie est non nulle.
N/A
u

Convertit un entier non signé en représentation décimale dddd .

  • Précision spécifie le nombre minimum de chiffres à afficher.
  • La précision par défaut est 1 .
  • Si la valeur convertie et la précision sont toutes deux ​ 0 ​ , la conversion ne produit aucun caractère.
N/A
f
F (C++11)

Convertit un nombre à virgule flottante en notation décimale selon le format [-]ddd.ddd .

  • Précision spécifie le nombre exact de chiffres à afficher après le séparateur décimal.
  • La précision par défaut est 6 .
  • Dans l' implémentation alternative , le séparateur décimal est écrit même si aucun chiffre ne le suit.
  • Pour le style de conversion des infinis et des NaN, voir les notes .
N/A N/A
double
double (C++11)
N/A N/A N/A N/A
long double
e
E

Convertit un nombre à virgule flottante en notation exponentielle décimale.

  • Pour le style de conversion e , la notation [-]d.ddd  e ±dd est utilisée.
  • Pour le style de conversion E , la notation [-]d.ddd  E ±dd est utilisée.
  • L'exposant contient au moins deux chiffres, plus de chiffres ne sont utilisés que si nécessaire.
  • Si la valeur est ​ 0 ​ , l'exposant est également ​ 0 ​ .
  • Précision spécifie le nombre exact de chiffres à afficher après le caractère de point décimal.
  • La précision par défaut est 6 .
  • Dans l' implémentation alternative , le caractère de point décimal est écrit même si aucun chiffre ne le suit.
  • Pour la conversion de l'infini et de la valeur non numérique, voir les notes .
N/A N/A N/A N/A N/A N/A
a
A

(C++11)

Convertit un nombre à virgule flottante en notation exponentielle hexadécimale.

  • Pour le style de conversion a , la notation [-]  0x h.hhh  p ±d est utilisée.
  • Pour le style de conversion A , la notation [-]  0X h.hhh  P ±d est utilisée.
  • Le premier chiffre hexadécimal n'est pas 0 si l'argument est une valeur à virgule flottante normalisée.
  • Si la valeur est ​ 0 ​ , l'exposant est également ​ 0 ​ .
  • Précision spécifie le nombre exact de chiffres à afficher après le caractère de point hexadécimal.
  • La précision par défaut est suffisante pour la représentation exacte de la valeur.
  • Dans l' implémentation alternative , le caractère de point décimal est écrit même si aucun chiffre ne le suit.
  • Pour la conversion de l'infini et de NaN, voir les notes .
N/A N/A N/A N/A N/A N/A
g
G

Convertit un nombre à virgule flottante en notation décimale ou en notation exponentielle décimale selon la valeur et la précision .

  • Pour le style de conversion g , la conversion sera effectuée avec le style e ou f .
  • Pour le style de conversion G , la conversion sera effectuée avec le style E ou f (jusqu'en C++11) F (depuis C++11) .
  • Soit P égal à la précision si elle est non nulle, 6 si la précision n'est pas spécifiée, ou 1 si la précision est ​ 0 ​ . Alors, si une conversion avec le style E aurait un exposant X :
    • Si P > X ≥ −4 , la conversion est effectuée avec le style f ou F (depuis C++11) et une précision P − 1 − X .
    • Sinon, la conversion est effectuée avec le style e ou E et une précision P − 1 .
  • Sauf si la représentation alternative est demandée, les zéros de fin sont supprimés, et le caractère de point décimal est également supprimé si aucune partie fractionnaire ne reste.
  • Pour la conversion de l'infini et de NaN, voir les notes .
N/A N/A N/A N/A N/A N/A
n

Retourne le nombre de caractères écrits jusqu'à présent par cet appel de la fonction.

  • Le résultat est écrit dans la valeur pointée par l'argument.
  • La spécification ne peut contenir aucun indicateur , largeur de champ , ou précision .
  • Pour le modificateur z , le type d'argument attendu est S * , où S est la version signée de std:: size_t .
signed char *
short *
int *
long *
long long *
※
N/A
p

Écrit une séquence de caractères définie par l'implémentation représentant un pointeur .

N/A N/A
void *
N/A N/A N/A N/A N/A N/A
Notes

Les fonctions de conversion en virgule flottante convertissent l'infini en inf ou infinity . Le choix est défini par l'implémentation.

La valeur non numérique est convertie en nan ou nan( char_sequence ) . Le choix est défini par l'implémentation.

Les conversions F , E , G , A produisent INF , INFINITY , NAN à la place.

Le spécificateur de conversion utilisé pour afficher char , unsigned char , signed char , short , et unsigned short attend des types promus des promotions d'arguments par défaut , mais avant l'affichage, sa valeur sera convertie en char , unsigned char , signed char , short , et unsigned short . Il est sûr de passer des valeurs de ces types en raison de la promotion qui a lieu lors de l'appel d'une fonction variadique.

Les spécifications de conversion correctes pour les types de caractères de largeur fixe ( std::int8_t , etc) sont définies dans l'en-tête <cinttypes> (bien que PRIdMAX , PRIuMAX , etc soient synonymes de %jd , %ju , etc).

Le spécificateur de conversion d'écriture en mémoire %n est une cible courante d'exploitations de sécurité lorsque les chaînes de format dépendent d'une entrée utilisateur.

Il y a un point de séquence après l'action de chaque spécificateur de conversion ; cela permet de stocker plusieurs résultats %n dans la même variable ou, comme cas particulier, d'afficher une chaîne modifiée par un précédent %n dans le même appel.

Si une spécification de conversion est invalide, le comportement est indéfini.

Valeur de retour

1,2) Nombre de caractères écrits en cas de succès ou une valeur négative en cas d'erreur.
3) Nombre de caractères écrits en cas de succès (sans inclure le caractère nul de fin) ou une valeur négative en cas d'erreur.
4) Nombre de caractères qui auraient été écrits pour un tampon suffisamment grand en cas de succès (sans inclure le caractère nul de fin), ou une valeur négative si une erreur s'est produite. Ainsi, la sortie (terminée par un caractère nul) a été complètement écrite si et seulement si la valeur retournée est non négative et inférieure à buf_size .

Notes

POSIX spécifie que errno est défini en cas d'erreur. Il spécifie également des spécifications de conversion supplémentaires, notamment la prise en charge du réordonnancement des arguments ( n$ immédiatement après % indique le n ième argument).

Appeler std::snprintf avec une buf_size nulle et un pointeur nul pour le buffer est utile (lorsque la surcharge d'un double appel est acceptable) pour déterminer la taille de buffer nécessaire pour contenir la sortie : 

auto fmt = "sqrt(2) = %f";
int sz = std::snprintf(nullptr, 0, fmt, std::sqrt(2));
std::vector<char> buf(sz + 1); // note +1 pour le terminateur nul
std::sprintf(buf.data(), fmt, std::sqrt(2)); // certain de tenir

Exemple

Exécuter ce code 
#include <cinttypes>
#include <cstdint>
#include <cstdio>
#include <limits>
int main()
{
    const char* s = "Hello";
    std::printf("Strings:\n"); // same as std::puts("Strings:");
    std::printf("\t[%10s]\n", s);
    std::printf("\t[%-10s]\n", s);
    std::printf("\t[%*s]\n", 10, s);
    std::printf("\t[%-10.*s]\n", 4, s);
    std::printf("\t[%-*.*s]\n", 10, 4, s);
    std::printf("Characters:\t%c %%\n", 'A');
    std::printf("Integers:\n");
    std::printf("\tDecimal:    \t%i %d %.6i %i %.0i %+i %i\n",
                                  1, 2,   3, 0,   0,  4,-4);
    std::printf("\tHexadecimal:\t%x %x %X %#x\n",
                                  5,10,10,  6);
    std::printf("\tOctal:      \t%o %#o %#o\n",
                                 10, 10,  4);
    std::printf("Floating point:\n");
    std::printf("\tRounding:\t%f %.0f %.32f\n", 1.5, 1.5, 1.3);
    std::printf("\tPadding:\t%05.2f %.2f %5.2f\n", 1.5, 1.5, 1.5);
    std::printf("\tScientific:\t%E %e\n", 1.5, 1.5);
    std::printf("\tHexadecimal:\t%a %A\n", 1.5, 1.5);
    std::printf("\tSpecial values:\t0/0=%g 1/0=%g\n", 0.0/0.0, 1.0/0.0);
    std::printf("Variable width control:\n");
    std::printf("\tright-justified variable width: '%*c'\n", 5, 'x');
    int r = std::printf("\tleft-justified variable width : '%*c'\n", -5, 'x');
    std::printf("(the last printf printed %d characters)\n", r);
    std::printf("Fixed-width types:\n");
    std::uint32_t val = std::numeric_limits<std::uint32_t>::max();
    std::printf("\tLargest 32-bit value is %" PRIu32 " or %#" PRIx32 "\n",
                                                 val,            val);
}

Sortie possible : 

Strings:
	[     Hello]
	[Hello     ]
	[     Hello]
	[Hell      ]
	[Hell      ]
Characters:	A %
Integers:
	Decimal:    	1 2 000003 0  +4 -4
	Hexadecimal:	5 a A 0x6
	Octal:      	12 012 04
Floating point:
	Rounding:	1.500000 2 1.30000000000000004440892098500626
	Padding:	01.50 1.50  1.50
	Scientific:	1.500000E+00 1.500000e+00
	Hexadecimal:	0x1.8p+0 0X1.8P+0
	Special values:	0/0=-nan 1/0=inf
Variable width control:
	right-justified variable width: '    x'
	left-justified variable width : 'x    '
(the last printf printed 41 characters)
Fixed-width types:
	Largest 32-bit value is 4294967295 or 0xffffffff

Voir aussi

imprime une sortie de caractères larges formatée vers stdout , un flux de fichier ou un tampon
(fonction)
(C++11)
imprime une sortie formatée vers stdout , un flux de fichier ou un tampon
en utilisant une liste d'arguments variables
(fonction)
écrit une chaîne de caractères dans un flux de fichier
(fonction)
lit une entrée formatée depuis stdin , un flux de fichier ou un tampon
(fonction)
(C++17)
convertit une valeur entière ou à virgule flottante en séquence de caractères
(fonction)
(C++23)
imprime vers stdout ou un flux de fichier en utilisant une 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)
Documentation C pour printf , fprintf , sprintf , snprintf