.\" -*- coding: UTF-8 -*-
'\" t
.\" Copyright (c) 1999 Andries Brouwer (aeb@cwi.nl)
.\"
.\" Earlier versions of this page influenced the present text.
.\" It was derived from a Berkeley page with version
.\"       @(#)printf.3    6.14 (Berkeley) 7/30/91
.\" converted for Linux by faith@cs.unc.edu, updated by
.\" Helmut.Geyer@iwr.uni-heidelberg.de, agulbra@troll.no and Bruno Haible.
.\"
.\" SPDX-License-Identifier: GPL-2.0-or-later
.\"
.\" 1999-11-25 aeb - Rewritten, using SUSv2 and C99.
.\" 2000-07-26 jsm28@hermes.cam.ac.uk - three small fixes
.\" 2000-10-16 jsm28@hermes.cam.ac.uk - more fixes
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH printf 3 "5 février 2023" "Pages du manuel de Linux 6.03" 
.SH NOM
printf, fprintf, dprintf, sprintf, snprintf, vprintf, vfprintf, vdprintf,
vsprintf, vsnprintf \- Formatage des sorties
.SH BIBLIOTHÈQUE
Bibliothèque C standard (\fIlibc\fP, \fI\-lc\fP)
.SH SYNOPSIS
.nf
\fB#include <stdio.h>\fP
.PP
\fBint printf(const char *restrict \fP\fIformat\fP\fB, ...);\fP
\fBint fprintf(FILE *restrict \fP\fIstream\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, ...);\fP
\fBint dprintf(int \fP\fIfd\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, ...);\fP
\fBint sprintf(char *restrict \fP\fIstr\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, ...);\fP
\fBint snprintf(char \fP\fIstr\fP\fB[restrict .\fP\fIsize\fP\fB], size_t \fP\fIsize\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, ...);\fP
.PP
\fBint vprintf(const char *restrict \fP\fIformat\fP\fB, va_list \fP\fIap\fP\fB);\fP
\fBint vfprintf(FILE *restrict \fP\fIstream\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, va_list \fP\fIap\fP\fB);\fP
\fBint vdprintf(int \fP\fIfd\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, va_list \fP\fIap\fP\fB);\fP
\fBint vsprintf(char *restrict \fP\fIstr\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, va_list \fP\fIap\fP\fB);\fP
\fBint vsnprintf(char \fP\fIstr\fP\fB[restrict .\fP\fIsize\fP\fB], size_t \fP\fIsize\fP\fB,\fP
\fB            const char *restrict \fP\fIformat\fP\fB, va_list \fP\fIap\fP\fB);\fP
.fi
.PP
.RS -4
Exigences de macros de test de fonctionnalités pour la glibc (consulter
\fBfeature_test_macros\fP(7))\ :
.RE
.PP
\fBsnprintf\fP(), \fBvsnprintf\fP()\ :
.nf
    _XOPEN_SOURCE >= 500 || _ISOC99_SOURCE
        || /* glibc <= 2.19: */ _BSD_SOURCE
.fi
.PP
\fBdprintf\fP(), \fBvdprintf\fP()\ :
.nf
    Depuis la glibc 2.10 :
        _POSIX_C_SOURCE >= 200809L
    Avant la glibc 2.10 :
        _GNU_SOURCE
.fi
.SH DESCRIPTION
Les fonctions de la famille \fBprintf\fP() produisent des sorties en accord
avec le \fIformat\fP décrit plus bas. Les fonctions \fBprintf\fP() et \fBvprintf\fP()
écrivent leur sortie sur \fIstdout\fP, le flux de sortie standard. \fBfprintf\fP()
et \fBvfprintf\fP() écrivent sur le flux \fIflux\fP indiqué. \fBsprintf\fP(),
\fBsnprintf\fP(), \fBvsprintf\fP() et \fBvsnprintf\fP() écrivent leurs sorties dans
la chaîne de caractères \fIchaîne\fP.
.PP
La fonction \fBdprintf\fP() est équivalente à \fBfprintf\fP() si ce n'est qu'elle
écrit dans un descripteur de fichier \fIfd\fP plutôt que dans un flux
\fIstdio\fP(3).
.PP
The functions \fBsnprintf\fP()  and \fBvsnprintf\fP()  write at most \fIsize\fP bytes
(including the terminating null byte (\[aq]\e0\[aq])) to \fIstr\fP.
.PP
Les fonctions \fBvprintf\fP(), \fBvfprintf\fP(), \fBvdprintf\fP(), \fBvsprintf\fP() et
\fBvsnprintf\fP() sont équivalentes aux fonctions \fBprintf\fP(), \fBfprintf\fP(),
\fBdprintf\fP(), \fBsprintf\fP() et \fBsnprintf\fP() respectivement, mais elles
emploient un tableau \fIva_list\fP à la place d'un nombre variable
d'arguments. Ces fonctions n'appellent pas la macro \fIva_end\fP. Du fait
qu'elles appellent la macro \fIva_arg\fP, la valeur de \fIap\fP n'est pas définie
après l'appel. Consultez \fBstdarg\fP(3).
.PP
Toutes ces fonctions écrivent leurs sorties sous le contrôle d'une chaîne de
\fIformat\fP qui indique les conversions à apporter aux arguments suivants (ou
accessibles à travers les arguments de taille variable de \fBstdarg\fP(3)).
.PP
C99 et POSIX.1\-2001 spécifient que les résultats ne sont pas définis si un
appel à \fBsprintf\fP(), \fBsnprintf\fP(), \fBvsprintf\fP() ou \fBvsnprintf\fP() causait
la copie entre des objets qui se chevauchent (par exemple, si le tableau de
la chaîne cible et un des paramètres d'entrée se trouvent dans le même
tampon). Consultez la section NOTES.
.SS "CHAÎNE DE FORMAT"
La chaîne de format est une chaîne de caractères, commençant et se terminant
dans son état de décalage initial, si présent. La chaîne de format est
composée de zéro ou plus d'indicateurs\ : les caractères ordinaires
(différents de \fB%\fP), qui sont copiés sans modification sur la sortie, et
les spécifications de conversion, qui chacune recherche un ou plus
d’arguments suivants. Les spécifications de conversion sont introduites par
le caractère \fB%\fP et se terminent par un \fIindicateur de conversion\fP. Entre
eux peuvent se trouver (dans l'ordre), zéro ou plusieurs \fIattributs\fP, une
valeur optionnelle de \fIlargeur minimale de champ\fP, une valeur optionnelle
de \fIprécision\fP et un éventuel \fImodificateur de longueur\fP.
.PP
La syntaxe générale d'un format de conversion est\ :
.PP
.in +4n
.nf
%[$][drapeaux][largeur][.précision][modificateur de longueur]conversion
.fi
.in
.PP
The arguments must correspond properly (after type promotion) with the
conversion specifier.  By default, the arguments are used in the order
given, where each \[aq]*\[aq] (see \fIField width\fP and \fIPrecision\fP below)
and each conversion specifier asks for the next argument (and it is an error
if insufficiently many arguments are given).  One can also specify
explicitly which argument is taken, at each place where an argument is
required, by writing "%m$" instead of \[aq]%\[aq] and "*m$" instead of
\[aq]*\[aq], where the decimal integer \fIm\fP denotes the position in the
argument list of the desired argument, indexed starting from 1.  Thus,
.PP
.in +4n
.EX
printf("%*d", width, num);
.EE
.in
.PP
et
.PP
.in +4n
.EX
printf("%2$*1$d", width, num);
.EE
.in
.PP
are equivalent.  The second style allows repeated references to the same
argument.  The C99 standard does not include the style using \[aq]$\[aq],
which comes from the Single UNIX Specification.  If the style using
\[aq]$\[aq] is used, it must be used throughout for all conversions taking
an argument and all width and precision arguments, but it may be mixed with
"%%" formats, which do not consume an argument.  There may be no gaps in the
numbers of arguments specified using \[aq]$\[aq]; for example, if arguments
1 and 3 are specified, argument 2 must also be specified somewhere in the
format string.
.PP
For some numeric conversions a radix character ("decimal point") or
thousands' grouping character is used.  The actual character used depends on
the \fBLC_NUMERIC\fP part of the locale.  (See \fBsetlocale\fP(3).)  The POSIX
locale uses \[aq].\[aq] as radix character, and does not have a grouping
character.  Thus,
.PP
.in +4n
.EX
printf("%\[aq].2f", 1234567.89);
.EE
.in
.PP
s'affichera comme «\ 1234567.89\ » dans la localisation POSIX, «\ 1\ 234\ 567,89\ » en localisation fr_FR, et «\ 1.234.567,89\ » en localisation da_DK.
.SS "Caractères d'attribut"
Le caractère % peut être éventuellement suivi par zéro ou plusieurs des
attributs suivants\ :
.TP 
\fB#\fP
The value should be converted to an "alternate form".  For \fBo\fP conversions,
the first character of the output string is made zero (by prefixing a 0 if
it was not zero already).  For \fBx\fP and \fBX\fP conversions, a nonzero result
has the string "0x" (or "0X" for \fBX\fP conversions) prepended to it.  For
\fBa\fP, \fBA\fP, \fBe\fP, \fBE\fP, \fBf\fP, \fBF\fP, \fBg\fP, and \fBG\fP conversions, the result
will always contain a decimal point, even if no digits follow it (normally,
a decimal point appears in the results of those conversions only if a digit
follows).  For \fBg\fP and \fBG\fP conversions, trailing zeros are not removed
from the result as they would otherwise be.  For \fBm\fP, if \fIerrno\fP contains
a valid error code, the output of \fIstrerrorname_np(errno)\fP is printed;
otherwise, the value stored in \fIerrno\fP is printed as a decimal number.  For
other conversions, the result is undefined.
.TP 
\fB\&0\fP
Indique le remplissage avec des zéros. Pour les conversions \fBd\fP, \fBi\fP,
\fBo\fP, \fBu\fP, \fBx\fP, \fBX\fP, \fBa\fP, \fBA\fP, \fBe\fP, \fBE\fP, \fBf\fP, \fBF\fP, \fBg\fP et \fBG\fP, la
valeur est complétée à gauche par des zéros plutôt que par des espaces. Si
les attributs \fB\&0\fP et \fB\-\fP apparaissent ensemble, l'attribut \fB\&0\fP est
ignoré. Si une précision est fournie avec une conversion numérique (\fBd\fP,
\fBi\fP, \fBo\fP, \fBu\fP, \fBx\fP et \fBX\fP), l'attribut \fB\&0\fP est ignoré. Pour les
autres conversions, le comportement est indéfini.
.TP 
\fB\-\fP
Indique que la valeur convertie doit être justifiée sur la limite gauche du
champ (par défaut elle l'est à droite). Les valeurs sont complétées à droite
par des espaces, plutôt qu'à gauche par des zéros ou des espaces. Un
attribut \fB\-\fP surcharge un attribut \fB\&0\fP si les deux sont fournis.
.TP 
\fB\[aq] \[aq]\fP
(une espace) Un blanc indique qu'une espace doit être laissée avant un
nombre positif (ou une chaîne vide) produit par une conversion signée
.TP 
\fB+\fP
Un signe (\fB+\fP ou \fB\-\fP) doit toujours être placé avant un nombre produit par
une conversion signée. Par défaut, un signe n'est utilisé que pour les
valeurs négatives. Un attribut \fB+\fP surcharge un attribut «\ espace\ » si
les deux sont fournis.
.PP
Les cinq caractères d'attributs ci\-dessus sont définis dans la norme C99,
les Spécifications UNIX Single en ajoutent un\ :
.TP 
\fB\[aq]\fP
For decimal conversion (\fBi\fP, \fBd\fP, \fBu\fP, \fBf\fP, \fBF\fP, \fBg\fP, \fBG\fP)  the
output is to be grouped with thousands' grouping characters if the locale
information indicates any.  (See \fBsetlocale\fP(3).)  Note that many versions
of \fBgcc\fP(1)  cannot parse this option and will issue a warning.  (SUSv2 did
not include \fI%\[aq]F\fP, but SUSv3 added it.)  Note also that the default
locale of a C program is "C" whose locale information indicates no
thousands' grouping character.  Therefore, without a prior call to
\fBsetlocale\fP(3), no thousands' grouping characters will be printed.
.PP
La glibc\ 2.2 ajoute un caractère d'attribut supplémentaire.
.TP 
\fBI\fP
.\" outdigits keyword in locale file
Pour les conversions décimales (\fBi\fP, \fBd\fP et \fBu\fP), la sortie emploie les
chiffres de la localisation alternative s'il y en a une. Par exemple, depuis
la glibc\ 2.2.3, cela donnera des chiffres arabes pour la localisation perse
(«\ fa_IR\ »).
.SS "Largeur de champ"
An optional decimal digit string (with nonzero first digit) specifying a
minimum field width.  If the converted value has fewer characters than the
field width, it will be padded with spaces on the left (or right, if the
left\-adjustment flag has been given).  Instead of a decimal digit string one
may write "*" or "*m$" (for some decimal integer \fIm\fP) to specify that the
field width is given in the next argument, or in the \fIm\fP\-th argument,
respectively, which must be of type \fIint\fP.  A negative field width is taken
as a \[aq]\-\[aq] flag followed by a positive field width.  In no case does a
nonexistent or small field width cause truncation of a field; if the result
of a conversion is wider than the field width, the field is expanded to
contain the conversion result.
.SS Précision
An optional precision, in the form of a period (\[aq].\[aq])  followed by an
optional decimal digit string.  Instead of a decimal digit string one may
write "*" or "*m$" (for some decimal integer \fIm\fP) to specify that the
precision is given in the next argument, or in the \fIm\fP\-th argument,
respectively, which must be of type \fIint\fP.  If the precision is given as
just \[aq].\[aq], the precision is taken to be zero.  A negative precision
is taken as if the precision were omitted.  This gives the minimum number of
digits to appear for \fBd\fP, \fBi\fP, \fBo\fP, \fBu\fP, \fBx\fP, and \fBX\fP conversions, the
number of digits to appear after the radix character for \fBa\fP, \fBA\fP, \fBe\fP,
\fBE\fP, \fBf\fP, and \fBF\fP conversions, the maximum number of significant digits
for \fBg\fP and \fBG\fP conversions, or the maximum number of characters to be
printed from a string for \fBs\fP and \fBS\fP conversions.
.SS "Modificateur de longueur"
Ici, une «\ conversion d’entier\ » correspond à \fBd\fP, \fBi\fP, \fBo\fP, \fBu\fP, \fBx\fP
ou \fBX\fP.
.TP 
\fBhh\fP
La conversion d’entier suivante correspond à un \fIsigned\ char\fP ou à un
\fIunsigned\ char\fP, ou la conversion \fBn\fP suivante correspond à un pointeur
sur un argument \fIsigned\ char\fP.
.TP 
\fBh\fP
La conversion d’entier suivante correspond à un \fIshort\fP ou à un \fIunsigned\ short\fP, ou la conversion \fBn\fP suivante correspond à un pointeur sur un
argument \fIshort\fP.
.TP 
\fBl\fP
(ell) A following integer conversion corresponds to a \fIlong\fP or \fIunsigned long\fP argument, or a following \fBn\fP conversion corresponds to a pointer to a
\fIlong\fP argument, or a following \fBc\fP conversion corresponds to a \fIwint_t\fP
argument, or a following \fBs\fP conversion corresponds to a pointer to
\fIwchar_t\fP argument.  On a following \fBa\fP, \fBA\fP, \fBe\fP, \fBE\fP, \fBf\fP, \fBF\fP,
\fBg\fP, or \fBG\fP conversion, this length modifier is ignored (C99; not in
SUSv2).
.TP 
\fBll\fP
(lettre l en double). La conversion d’entier suivante correspond à un
\fIlong\ long\fP ou à un \fIunsigned\ long\ long\fP, ou la conversion \fBn\fP
suivante correspond à un pointeur sur un \fIlong\ long\fP.
.TP 
\fBq\fP
Un synonyme de \fBll\fP. Il s'agit d'une extension non standard, dérivée de
BSD\ ; évitez son utilisation dans du nouveau code.
.TP 
\fBL\fP
La conversion \fBa\fP, \fBA\fP, \fBe\fP, \fBE\fP, \fBf\fP, \fBF\fP, \fBg\fP ou \fBG\fP suivante
correspond à un argument \fIlong\ double\fP (C99 autorise %LF mais pas SUSv2).
.TP 
\fBj\fP
La conversion d’entier suivante correspond à un argument \fIintmax_t\fP ou
\fIuintmax_t\fP, ou la conversion \fBn\fP suivante correspond à un pointeur sur un
argument \fIintmax_t\fP.
.TP 
\fBz\fP
La conversion d’entier suivante correspond à un argument \fIsize_t\fP ou
\fIssize_t\fP, ou la conversion \fBn\fP suivante correspond à un pointeur sur un
argument \fIsize_t\fP.
.TP 
\fBZ\fP
Un synonyme non standard de \fBz\fP qui précède l'apparition de \fBz\fP. Ne pas
l'utiliser dans du nouveau code.
.TP 
\fBt\fP
La conversion d’entier suivante correspond à un argument \fIptrdiff_t\fP, ou la
conversion \fBn\fP suivante correspond à un pointeur sur un argument
\fIptrdiff_t\fP.
.PP
SUSv3 mentionne tous les modificateurs précédents à l'exception des
extensions non standard. Les spécifications SUSv2 ne mentionnent que les
modificateurs de longueur \fBh\fP (dans \fBhd\fP, \fBhi\fP, \fBho\fP, \fBhx\fP, \fBhX\fP et
\fBhn\fP), \fBl\fP (dans \fBld\fP, \fBli\fP, \fBlo\fP, \fBlx\fP, \fBlX\fP, \fBln\fP, \fBlc\fP et \fBls\fP)
et \fBL\fP (dans \fBLe\fP, \fBLE\fP, \fBLf\fP, \fBLg\fP et \fBLG\fP).
.PP
.\"
En tant qu’extension non standard, l'implémentation GNU traite \fBll\fP et \fBL\fP
comme des synonymes de façon à ce qu'il soit possible, par exemple, d'écrire
\fBllg\fP (comme synonyme conforme aux standards de \fBLg\fP) et \fBLd\fP (comme
synonyme conforme aux standards de \fBlld\fP). Une telle utilisation n'est pas
portable.
.SS "Indicateurs de conversion"
Un caractère indique le type de conversion à apporter. Les indicateurs de
conversion et leurs significations sont\ :
.TP 
\fBd\fP, \fBi\fP
L'argument \fIint\fP est converti en un chiffre décimal signé. La précision, si
elle est mentionnée, correspond au nombre minimal de chiffres qui doivent
apparaître. Si la conversion fournit moins de chiffres, le résultat est
rempli à gauche avec des zéros. Par défaut la précision
vaut\ \fB1\fP. Lorsque\ \fB0\fP est converti avec une précision valant\ \fB0\fP, la
sortie est vide.
.TP 
\fBo\fP, \fBu\fP, \fBx\fP, \fBX\fP
L'argument \fIunsigned int\fP est converti en un chiffre octal non signé
(\fBo\fP), un chiffre décimal non signé (\fBu\fP) ou un chiffre hexadécimal non
signé (\fBx\fP et \fBX\fP). Les lettres \fBabcdef\fP sont utilisées pour les
conversions avec \fBx\fP, les lettres \fBABCDEF\fP sont utilisées pour les
conversions avec \fBX\fP. La précision, si elle est indiquée, donne un nombre
minimal de chiffres à faire apparaître. Si la valeur convertie nécessite
moins de chiffres, elle est complétée à gauche avec des zéros. La précision
par défaut vaut\ \fB1\fP. Lorsque\ \fB0\fP est converti avec une précision
valant\ \fB0\fP, la sortie est vide.
.TP 
\fBe\fP, \fBE\fP
L'argument, de type \fIdouble\fP, est arrondi et présenté avec la notation
scientifique [\-]c\fB\&.\fPccc\fBe\fP\(+-cc dans lequel se trouve un chiffre (qui
n'est pas nul si l'argument n'est pas nul) avant le point, puis un nombre de
décimales égal à la précision demandée. Si la précision n'est pas indiquée,
l'affichage contiendra 6\ décimales. Si la précision vaut zéro, il n'y a pas
de point décimal. Une conversion \fBE\fP utilise la lettre \fBE\fP (plutôt que
\fBe\fP) pour introduire l'exposant. Celui\-ci contient toujours au moins deux
chiffres. Si la valeur affichée est nulle, son exposant est 00.
.TP 
\fBf\fP, \fBF\fP
L'argument, de type \fIdouble\fP, est arrondi et présenté avec la notation
classique [\-]ccc\fB\&.\fPccc, où le nombre de décimales est égal à la précision
réclamée. Si la précision n'est pas indiquée, l'affichage se fera avec
6\ décimales. Si la précision vaut zéro, aucun point n'est affiché. Lorsque
le point est affiché, il y a toujours au moins un chiffre devant.
.IP
SUSv2 ne mentionne pas \fBF\fP et dit qu'une représentation des chaînes de
caractères pour l'infini ou NaN devrait être disponible. SUSv3 ajoute
l'indicateur \fBF\fP. La norme C99 précise «\ [\-]inf\ » ou «\ [\-]infinity\ »
pour les infinis, et une chaîne commençant par «\ nan\ » pour NaN dans le
cas d'une conversion \fBf\fP, et les chaînes «\ [\-]INF\ », «\ [\-]INFINITY\ » ou
«\ NAN*\ » pour une conversion \fBF\fP.
.TP 
\fBg\fP, \fBG\fP
L'argument, de type \fIdouble\fP, est converti en style \fBf\fP ou \fBe\fP (\fBF\fP ou
\fBE\fP pour la conversion \fBG\fP). La précision indique le nombre de décimales
significatives. Si la précision est absente, une valeur par défaut de \fB6\fP
est utilisée. Si la précision vaut\ \fB0\fP, elle est considérée comme valant
\fB1\fP. La notation scientifique \fBe\fP est utilisée si l'exposant est inférieur
à \-4 ou supérieur ou égal à la précision demandée. Les zéros en fin de
partie décimale sont supprimés. Un point décimal n'est affiché que s'il est
suivi d'au moins un chiffre.
.TP 
\fBa\fP, \fBA\fP
(C99, pas dans SUSv2, mais rajouté dans SUSv3). Pour la conversion \fBa\fP,
l'argument de type \fIdouble\fP est transformé en notation hexadécimale (avec
les lettres abcdef) de forme [\-]\fB0x\fPh\fB\&.\fPhhhh\fBp\fP\(+-d\ ; pour la
conversion \fBA\fP, le préfixe \fB0X\fP, les lettres ABCDEF et le séparateur
d'exposant \fBP\fP sont utilisés. Il y a un chiffre hexadécimal avant la
virgule et le nombre de chiffres ensuite est égal à la précision. La
précision par défaut suffit pour une représentation exacte de la valeur, si
une représentation exacte est possible en base\ 2. Sinon, elle est
suffisamment grande pour distinguer les valeurs de type \fIdouble\fP. Le
chiffre avant le point décimal n'est pas spécifié pour les nombres non
normalisés et il est non nul mais non spécifié pour les nombres normalisés.
.TP 
\fBc\fP
S'il n'y a pas de modificateur \fBl\fP, l'argument, de type \fIint\fP, est
converti en un \fIunsigned\ char\fP et le caractère correspondant est
affiché. Si un modificateur \fBl\fP est présent, l'argument de type \fIwint_t\fP
(caractère large) est converti en séquence multioctet par un appel à
\fBwcrtomb\fP(3), avec un état de conversion débutant dans l'état initial. La
chaîne multioctet résultante est écrite.
.TP 
\fBs\fP
If no \fBl\fP modifier is present: the \fIconst char\ *\fP argument is expected to
be a pointer to an array of character type (pointer to a string).
Characters from the array are written up to (but not including) a
terminating null byte (\[aq]\e0\[aq]); if a precision is specified, no more
than the number specified are written.  If a precision is given, no null
byte need be present; if the precision is not specified, or is greater than
the size of the array, the array must contain a terminating null byte.
.IP
Si un modificateur \fBl\fP est présent, l'argument de type \fIconst wchar_t\ *\fP
est supposé être un pointeur sur un tableau de caractères larges. Les
caractères larges du tableau sont convertis en une séquence de caractères
multioctets (chacun par un appel de \fBwcrtomb\fP(3), avec un état de
conversion dans l'état initial avant le premier caractère large), cela
jusqu'au caractère large NULL final compris. Les caractères multioctets
résultants sont écrits jusqu'à l’octet NULL final (non compris). Si une
précision est fournie, il n'y a pas plus d'octets écrits que la précision
indiquée, mais aucun caractère multioctet n'est écrit
partiellement. Remarquez que la précision concerne le nombre d'\fIoctets\fP
écrits et non pas le nombre de \fIcaractères larges\fP ou de \fIpositions d'écrans\fP. La chaîne doit contenir un caractère large NULL final, sauf si
une précision est indiquée et est suffisamment petite pour que le nombre
d'octets écrits la remplisse avant la fin de la chaîne.
.TP 
\fBC\fP
(Ni dans C99, ni dans C11, mais dans SUSv2, SUSv3 et SUSv4). Synonyme de
\fBlc\fP. Ne pas utiliser.
.TP 
\fBS\fP
(Ni dans C99, ni dans C11, mais dans SUSv2, SUSv3 et SUSv4). Synonyme de
\fBls\fP. Ne pas utiliser.
.TP 
\fBp\fP
L'argument pointeur, du type \fIvoid\ *\fP est affiché en hexadécimal, comme
avec \fB%#x\fP ou \fB%#lx\fP.
.TP 
\fBn\fP
Le nombre de caractères écrits jusqu'à présent est stocké dans l'entier
pointé par l'argument correspondant. Cet argument doit être un \fIint\ *\fP ou
une variante dont la taille correspond au modificateur de longueur d'entier
optionnellement fourni. Aucun argument n'est converti (cet indicateur n'est
pas pris en charge par la bibliothèque\ C Bionic). Le comportement n'est pas
défini si la spécification de conversion comporte un drapeau, une longueur
de champ ou une précision.
.TP 
\fBm\fP
(glibc extension; supported by uClibc and musl.)  Print output of
\fIstrerror(errno)\fP (or \fIstrerrorname_np(errno)\fP in the alternate form).  No
argument is required.
.TP 
\fB%\fP
A \[aq]%\[aq] is written.  No argument is converted.  The complete
conversion specification is \[aq]%%\[aq].
.SH "VALEUR RENVOYÉE"
En cas de succès, ces fonctions renvoient le nombre de caractères affichés
(sans compter l'octet NULL final utilisé pour terminer les sorties dans les
chaînes).
.PP
The functions \fBsnprintf\fP()  and \fBvsnprintf\fP()  do not write more than
\fIsize\fP bytes (including the terminating null byte (\[aq]\e0\[aq])).  If the
output was truncated due to this limit, then the return value is the number
of characters (excluding the terminating null byte)  which would have been
written to the final string if enough space had been available.  Thus, a
return value of \fIsize\fP or more means that the output was truncated.  (See
also below under NOTES.)
.PP
Si une erreur de sortie s'est produite, une valeur négative est renvoyée.
.SH VERSIONS
.\" Linux libc4 knows about the five C standard flags.
.\" It knows about the length modifiers \fBh\fP, \fBl\fP, \fBL\fP,
.\" and the conversions
.\" \fBc\fP, \fBd\fP, \fBe\fP, \fBE\fP, \fBf\fP, \fBF\fP,
.\" \fBg\fP, \fBG\fP, \fBi\fP, \fBn\fP, \fBo\fP, \fBp\fP,
.\" \fBs\fP, \fBu\fP, \fBx\fP, and \fBX\fP,
.\" where \fBF\fP is a synonym for \fBf\fP.
.\" Additionally, it accepts \fBD\fP, \fBO\fP, and \fBU\fP as synonyms
.\" for \fBld\fP, \fBlo\fP, and \fBlu\fP.
.\" (This is bad, and caused serious bugs later, when
.\" support for \fB%D\fP disappeared.)
.\" No locale-dependent radix character,
.\" no thousands' separator, no NaN or infinity, no "%m$" and "*m$".
.\" .PP
.\" Linux libc5 knows about the five C standard flags and the \[aq] flag,
.\" locale, "%m$" and "*m$".
.\" It knows about the length modifiers \fBh\fP, \fBl\fP, \fBL\fP,
.\" \fBZ\fP, and \fBq\fP, but accepts \fBL\fP and \fBq\fP
.\" both for \fIlong double\fP and for \fIlong long\fP (this is a bug).
.\" It no longer recognizes \fBF\fP, \fBD\fP, \fBO\fP, and \fBU\fP,
.\" but adds the conversion character
.\" .BR m ,
.\" which outputs
.\" .IR strerror(errno) .
.\" .PP
.\" glibc 2.0 adds conversion characters \fBC\fP and \fBS\fP.
.\" .PP
La bibliothèque glibc\ 2.1 ajoute les modificateurs de longueur \fBhh\fP, \fBj\fP,
\fBt\fP et \fBz\fP et les caractères de conversion \fBa\fP et\ \fBA\fP.
.PP
La bibliothèque glibc\ 2.2 ajoute le caractère de conversion \fBF\fP avec la
sémantique C99 et le caractère d'attribut\ \fBI\fP.
.PP
glibc 2.35 gives a meaning to the alternate form (\fB#\fP)  of the \fBm\fP
conversion specifier, that is \fI%#m\fP.
.SH ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter
\fBattributes\fP(7).
.ad l
.nh
.TS
allbox;
lbx lb lb
l l l.
Interface	Attribut	Valeur
T{
\fBprintf\fP(),
\fBfprintf\fP(),
\fBsprintf\fP(),
\fBsnprintf\fP(),
\fBvprintf\fP(),
\fBvfprintf\fP(),
\fBvsprintf\fP(),
\fBvsnprintf\fP()
T}	Sécurité des threads	MT\-Safe locale
.TE
.hy
.ad
.sp 1
.SH STANDARDS
\fBfprintf\fP(), \fBprintf\fP(), \fBsprintf\fP(), \fBsnprintf\fP(), \fBvprintf\fP(),
\fBvfprintf\fP(), \fBvsprintf\fP(), \fBvsnprintf\fP(): POSIX.1\-2001, POSIX.1\-2008,
C99.
.PP
\fBdprintf\fP() et \fBvdprintf\fP() sont originellement des extensions GNU. Elles
ont été standardisées dans POSIX.1\-2008.
.PP
En ce qui concerne la valeur de retour de \fBsnprintf\fP(), SUSv2 et C99 sont
en contradiction\ : lorsque \fBsnprintf\fP() est appelée avec un argument
\fItaille\fP=\fI0\fP, SUSv2 précise une valeur de retour indéterminée, inférieure
à 1, alors que C99 autorise \fIchaîne\fP à être NULL dans ce cas, et renvoie
(comme toujours) le nombre de caractères qui auraient été écrits si la
chaîne de sortie avait été assez grande. Les spécifications de \fBsnprintf\fP()
dans POSIX.1\-2001 et ses versions supérieures sont alignées avec C99.
.SH NOTES
Certains programmes reposent imprudemment sur du code comme\ :
.PP
.in +4n
.EX
sprintf(buf, "%s some further text", buf);
.EE
.in
.PP
.\" http://sourceware.org/bugzilla/show_bug.cgi?id=7075
pour ajouter du texte à \fIbuf\fP. Cependant, les normes indiquent
explicitement que le résultat n'est pas défini si les tampons de source et
de destination se recouvrent lors d'un appel à \fBsprintf\fP(), \fBsnprintf\fP(),
\fBvsprintf\fP() et \fBvsnprintf\fP(). En fonction de la version de \fBgcc\fP(1)
utilisée et des options de compilation, ces appels \fBne\fP produiront \fBpas\fP
le résultat attendu.
.PP
.\" .SH HISTORY
.\" UNIX V7 defines the three routines
.\" .BR printf (),
.\" .BR fprintf (),
.\" .BR sprintf (),
.\" and has the flag \-, the width or precision *, the length modifier l,
.\" and the conversions doxfegcsu, and also D,O,U,X as synonyms for ld,lo,lu,lx.
.\" This is still true for 2.9.1BSD, but 2.10BSD has the flags
.\" #, + and <space> and no longer mentions D,O,U,X.
.\" 2.11BSD has
.\" .BR vprintf (),
.\" .BR vfprintf (),
.\" .BR vsprintf (),
.\" and warns not to use D,O,U,X.
.\" 4.3BSD Reno has the flag 0, the length modifiers h and L,
.\" and the conversions n, p, E, G, X (with current meaning)
.\" and deprecates D,O,U.
.\" 4.4BSD introduces the functions
.\" .BR snprintf ()
.\" and
.\" .BR vsnprintf (),
.\" and the length modifier q.
.\" FreeBSD also has functions
.\" .BR asprintf ()
.\" and
.\" .BR vasprintf (),
.\" that allocate a buffer large enough for
.\" .BR sprintf ().
.\" In glibc there are functions
.\" .BR dprintf ()
.\" and
.\" .BR vdprintf ()
.\" that print to a file descriptor instead of a stream.
The glibc implementation of the functions \fBsnprintf\fP()  and \fBvsnprintf\fP()
conforms to the C99 standard, that is, behaves as described above, since
glibc 2.1.  Until glibc 2.0.6, they would return \-1 when the output was
truncated.
.SH BOGUES
.\" .PP
.\" Linux libc4.[45] does not have a
.\" .BR snprintf (),
.\" but provides a libbsd that contains an
.\" .BR snprintf ()
.\" equivalent to
.\" .BR sprintf (),
.\" that is, one that ignores the
.\" .I size
.\" argument.
.\" Thus, the use of
.\" .BR snprintf ()
.\" with early libc4 leads to serious security problems.
Comme \fBsprintf\fP() et \fBvsprintf\fP() ne font pas de suppositions sur la
longueur des chaînes, le programme appelant doit s'assurer de ne pas
déborder l'espace d'adressage. C'est souvent difficile. Notez que la
longueur des chaînes peut varier avec la localisation et être difficilement
prévisible. Il faut alors utiliser \fBsnprintf\fP() ou \fBvsnprintf\fP() à la
place (ou encore \fBasprintf\fP(3) et \fBvasprintf\fP(3)).
.PP
.\" .PP
.\" Some floating-point conversions under early libc4
.\" caused memory leaks.
Un code tel que \fBprintf(\fP\fItoto\fP\fB);\fP indique souvent un bogue, car \fItoto\fP
peut contenir un caractère «\ %\ ». Si \fItoto\fP vient d'une saisie non
sécurisée, il peut contenir \fB%n\fP, ce qui autorise \fBprintf\fP() à écrire dans
la mémoire, et crée une faille de sécurité.
.SH EXEMPLES
Pour afficher \fIPi\fP avec cinq décimales\ :
.PP
.in +4n
.EX
#include <math.h>
#include <stdio.h>
fprintf (stdout, "pi = %.5f\en", 4 * atan (1.0));
.EE
.in
.PP
Pour afficher une date et une heure sous la forme «\ Sunday, July 3, 23:15\ », où \fIjour_semaine\fP et \fImois\fP sont des pointeurs sur des chaînes\ :
.PP
.in +4n
.EX
#include <stdio.h>
fprintf(stdout, "%s, %s %d, %.2d:%.2d\en",
        jour_semaine, mois, jour, heure, minute);
.EE
.in
.PP
De nombreux pays utilisent un format de date différent, comme
jour\-mois\-année. Une version internationale doit donc être capable
d'afficher les arguments dans l'ordre indiqué par le format\ :
.PP
.in +4n
.EX
#include <stdio.h>
fprintf(stdout, format,
        jour_semaine, mois, jour, heure, min);
.EE
.in
.PP
où le \fIformat\fP dépend de la localisation et peut permuter les
arguments. Avec la valeur\ :
.PP
.in +4n
.EX
"%1$s, %3$d. %2$s, %4$d:%5$.2d\fr"
.EE
.in
.PP
On peut obtenir «\ Dimanche, 3\ juillet, 23:15\ ».
.PP
Pour allouer une chaîne de taille suffisante et écrire dedans (code correct
aussi bien pour la glibc\ 2.0 que pour la glibc\ 2.1)\ :
.PP
.EX
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

char *
make_message(const char *fmt, ...)
{
    int n = 0;
    size_t size = 0;
    char *p = NULL;
    va_list ap;

    /* Déterminer la taille requise. */

    va_start(ap, fmt);
    n = vsnprintf(p, size, fmt, ap);
    va_end(ap);

    if (n < 0)
        return NULL;

    size = (size_t) n + 1;      /* One extra byte for \[aq]\e0\[aq] */
    p = malloc(size);
    if (p == NULL)
        return NULL;

    va_start(ap, fmt);
    n = vsnprintf(p, size, fmt, ap);
    va_end(ap);

    if (n < 0) {
        free(p);
        return NULL;
    }

    return p;
}
.EE
.PP
If truncation occurs in glibc versions prior to glibc 2.0.6, this is treated
as an error instead of being handled gracefully.
.SH "VOIR AUSSI"
\fBprintf\fP(1), \fBasprintf\fP(3), \fBputs\fP(3), \fBscanf\fP(3), \fBsetlocale\fP(3),
\fBstrfromd\fP(3), \fBwcrtomb\fP(3), \fBwprintf\fP(3), \fBlocale\fP(5)
.PP
.SH TRADUCTION
La traduction française de cette page de manuel a été créée par
Christophe Blaess <https://www.blaess.fr/christophe/>,
Stéphan Rafin <stephan.rafin@laposte.net>,
Thierry Vignaud <tvignaud@mandriva.com>,
François Micaux,
Alain Portal <aportal@univ-montp2.fr>,
Jean-Philippe Guérard <fevrier@tigreraye.org>,
Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>,
Julien Cristau <jcristau@debian.org>,
Thomas Huriaux <thomas.huriaux@gmail.com>,
Nicolas François <nicolas.francois@centraliens.net>,
Florentin Duneau <fduneau@gmail.com>,
Simon Paillard <simon.paillard@resel.enst-bretagne.fr>,
Denis Barbier <barbier@debian.org>,
David Prévot <david@tilapin.org>,
Frédéric Hantrais <fhantrais@gmail.com>
et
Grégoire Scano <gregoire.scano@malloc.fr>
.
.PP
Cette traduction est une documentation libre ; veuillez vous reporter à la
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License version 3
.UE
concernant les conditions de copie et 
de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
.PP
Si vous découvrez un bogue dans la traduction de cette page de manuel, 
veuillez envoyer un message à
.MT debian-l10n-french@lists.debian.org
.ME .