printf ()- Imprimer les caractères formatés
Format
#include <stdio.h>
int printf(const char *format-string, argument-list);Niveau de langue
American National Standards Institute
Unités d'exécution protégées
Oui
Sensible à l'environnement local
Le comportement de cette fonction peut être affecté par les catégories LC_CTYPE et LC_NUMERIC de l'environnement local en cours. Le comportement peut également être affecté par la catégorie LC_UNI_CTYPE de l'environnement local en cours si LOCALETYPE (*LOCALEUCS2) ou LOCALETYPE (*LOCALEUTF) est spécifié dans la commande de compilation. Pour plus d'informations, voir Présentation des CCSID et des environnements locaux.
Description
La fonction printf() formate et imprime une série de caractères et de valeurs dans le flux de sortie standard stdout. Les spécifications de format, commençant par le signe de pourcentage (%), déterminent le format de sortie pour toute liste d'arguments suivant la chaîne de format. La chaîne de format est une chaîne de caractères multi-octets commençant et se terminant par son état de décalage initial.
La chaîne de format est lue de gauche à droite. Lorsque la première spécification de format est trouvée, la valeur du premier argument après format-string est convertie et imprimée conformément à la spécification de format. La deuxième spécification de format entraîne la conversion et l'impression du deuxième argument après format-string , et ainsi de suite jusqu'à la fin de la chaîne de format . S'il existe plus d'arguments que de spécifications de format, les arguments supplémentaires sont évalués et ignorés. Les résultats ne sont pas définis s'il n'y a pas suffisamment d'arguments pour toutes les spécifications de format.
Une spécification de format se présente sous la forme suivante:
Les conversions peuvent être appliquées au nième argument après la chaîne-format dans la liste des arguments, plutôt qu'à l'argument non utilisé suivant. Dans ce cas, le caractère de conversion% est remplacé par la séquence %n$, où n est un entier décimal compris entre 1 et NL_ARGMAX, ce qui donne la position de l'argument dans la liste des arguments. Cette fonction permet de définir des chaînes de format qui sélectionnent des arguments dans un ordre adapté à des langues spécifiques.
Comme alternative, des entrées spécifiques de la liste d'arguments peuvent être affectées à l'aide de la spécification de format décrite dans le diagramme précédent. Cette spécification de format et la spécification de format précédente ne peuvent pas être mélangées dans le même appel à printf(). Sinon, des résultats imprévisibles peuvent se produire.
La valeur arg-number est une constante entière positive où 1 fait référence à la première entrée de la liste d'arguments. Arg-number ne peut pas être supérieur au nombre d'entrées de la liste d'arguments, sinon les résultats ne sont pas définis. Arg-number ne peut pas être supérieur à NL_ARGMAX.
Dans les chaînes de format contenant la forme %n$ des spécifications de conversion, les arguments numérotés de la liste d'arguments peuvent être référencés à partir de la chaîne de format autant de fois que nécessaire.
Dans les chaînes de format contenant la forme %n$ d'une spécification de conversion, la largeur ou la précision d'une zone peut être indiquée par la séquence * m$, où m est un entier décimal compris entre 1 et NL_ARGMAX donnant la position dans la liste des arguments (après l'argument de format) d'un argument entier contenant la largeur ou la précision de la zone, par exemple:
printf("%1$d:%2$.*3$d:%4$.*3$d\n", hour, min, precision, sec);La chaîne de format peut contenir soit des spécifications d'argument numérotées (c'est-à-dire %n$ et * m$), soit des spécifications d'argument non numérotées (c'est-à-dire% et *), mais normalement pas les deux. La seule exception à cette règle est que%% peut être mélangé avec le formulaire %n$. Les résultats de la combinaison de spécifications d'arguments numérotés et non numérotés dans une chaîne de chaîne de format ne sont pas définis. Lorsque des spécifications d'arguments numérotés sont utilisées, la spécification du nième argument requiert que tous les arguments de début, du premier au (n-1) ième, soient spécifiés dans la chaîne de format.
Chaque zone de la spécification de format est un caractère unique ou un nombre indiquant une option de format particulière. Le caractère type , qui apparaît après la dernière zone de format facultative, détermine si l'argument associé est interprété comme un caractère, une chaîne, un nombre ou un pointeur. La spécification de format la plus simple contient uniquement le signe de pourcentage et un caractère type (par exemple, %s).
- Zone
- Description
- indicateurs
- Justification de la sortie et de l'impression des signes, des blancs, des décimales, des préfixes octaux et hexadécimaux, ainsi que la sémantique de l'unité de précision wchar_t .
- largeur
- Nombre minimal d'octets de sortie.
- précision
- Voir Tableau 2.
- h, l, ll, L, H, D, DD
- Taille de l'argument attendue:
- h
- Préfixe avec les types d, i, o, u, x, Xet n qui indique que l'argument est un entier court ou un entier court non signé.
- l
- Préfixe avec les types d, i, o, u, x, Xet n qui indique que l'argument est un entier long ou entier long non signé.
- ll
- Préfixe avec les types d, i, o, u, x, Xet n qui indique que l'argument est un long long int ou long long intnon signé.
- L
- Préfixe avec les types a, A, e, E, f, F, gou G qui indique que l'argument est long double.
- H
- Un préfixe avec les types a, A, e, E, f, F, gou G qui indique que l'argument est _Decimal32.
- D
- Un préfixe avec les types a, A, e, E, f, F, gou G qui indique que l'argument est _Decimal64.
- JJ
- Préfixe avec les types a, A, e, E, f, F, gou G qui indique que l'argument est _Decimal128.
Chaque zone de la spécification de format est examinée en détail ci-dessous. Si un signe de pourcentage (%) est suivi d'un caractère qui n'a aucune signification en tant que zone de format, le comportement n'est pas défini. Une exception à ce comportement est %%. Pour imprimer un signe de pourcentage, utilisez %%.
Les caractères type et leur signification sont indiqués dans le tableau suivant:
| Caractère | Argument | Format de sortie |
|---|---|---|
| a | virgule flottante | Pour les nombres à virgule flottante non décimale, valeur signée au format [-] 0xh.hhhhp [signe]ddd, où h est un chiffre hexadécimal unique, hhhh est un ou plusieurs chiffres hexadécimaux, ddd est un ou plusieurs chiffres décimaux et signe est + ou-. Le nombre de chiffres hexadécimaux après le séparateur décimal est égal à la précision demandée. Pour les nombres à virgule flottante décimale, si la précision est manquante, le formatage de style f ou e est utilisé en fonction des critères suivants.
|
| A | virgule flottante | Identique au format a, sauf que les caractères alphabétiques en majuscules sont utilisés à la place des caractères alphabétiques en minuscules. |
| d, i | Nombre entier | Entier décimal signé. |
| u | Nombre entier | Entier décimal non signé. |
| o | Nombre entier | Entier octal non signé. |
| x | Nombre entier | Entier hexadécimal non signé, utilisant abcdef. |
| X | Nombre entier | Entier hexadécimal non signé, utilisant ABCDEF. |
| D (n, p) | Décimale condensée | Il est au format [-] dddd.dddd où le nombre de chiffres après le séparateur décimal est égal à la précision de la spécification. Si la précision est manquante, la valeur par défaut est p; si la précision est égale à zéro et que l'indicateur # n'est pas spécifié, aucun séparateur décimal n'apparaît. Si n et p sont *, un argument de la liste d'arguments fournit la valeur. n et p doivent précéder la valeur formatée dans la liste d'arguments. Au moins un caractère apparaît avant un séparateur décimal. La valeur est arrondie au nombre de chiffres approprié. |
| f | virgule flottante | Valeur signée au format [-]dddd.dddd, où dddd correspond à un ou plusieurs chiffres décimaux. Le nombre de chiffres avant le séparateur décimal dépend de l'ampleur du nombre. Le nombre de chiffres après le séparateur décimal est égal à la précision demandée.2 |
| F | virgule flottante | Identique au format f, sauf que les caractères alphabétiques en majuscules sont utilisés à la place des caractères alphabétiques en minuscules.2 |
| e | virgule flottante | Valeur signée au format [-]d.dddd e[signe]ddd, où d est un chiffre décimal unique, dddd est un ou plusieurs chiffres décimaux, ddd est 2 chiffres décimaux ou plus et signe est + ou-.2 |
| E | virgule flottante | Identique au format e , sauf que les caractères alphabétiques en majuscules sont utilisés à la place des caractères alphabétiques en minuscules.2 |
| g | virgule flottante | Valeur signée imprimée au format f ou e . Le format e n'est utilisé que lorsque l'exposant de la valeur est inférieur à -4 ou supérieur ou égal à précision. Les zéros de fin sont tronqués et le séparateur décimal n'apparaît que si un ou plusieurs chiffres le suivent.2 |
| G | virgule flottante | Identique au format g, sauf que les caractères alphabétiques en majuscules sont utilisés à la place des caractères alphabétiques en minuscules.2 |
| c | Caractère (octet) | Caractère unique. |
| s | Chaîne | Caractères (octets) imprimés jusqu'au premier caractère nul (\0) ou jusqu'à ce que la précision soit atteinte. |
| n | Pointeur vers un entier | Nombre de caractères (octets) écrits jusqu'à présent dans le flux ou la mémoire tampon ; cette valeur est stockée dans l'entier dont l'adresse est indiquée comme argument. |
| p | Pointeur | Pointeur converti en une séquence de caractères imprimables. Il peut s'agir de l'un des éléments suivants:
|
| lc ou C | caractère large | Le caractère (wchar_t) est converti en caractère multi-octet comme par un appel à wctomb (), et ce caractère est imprimé.1 |
| ls ou S | caractère large | Les caractères (wchar_t) jusqu'au premier caractère null (wchar_t) (L\0), ou jusqu'à ce que la précision soit atteinte, sont convertis en caractères multi-octets, comme par un appel à wcstombs (), et ces caractères sont imprimés. Si l'argument est une chaîne nulle, (null) est imprimé.1 |
- Pour plus d'informations, voir la documentation de la fonction
wctomb()ou la documentation de la fonctionwcstombs(). Vous pouvez également trouver des informations supplémentaires dans Caractères larges. - Si les spécificateurs de taille de format H, D ou DD ne sont pas utilisés, seuls 15 chiffres significatifs de sortie sont garantis.
La liste suivante présente le format des valeurs imprimées pour les pointeurs IBM® i et fournit une brève description des composants des valeurs imprimées.
Context: type, sous-type et nom du contexte
Object: type, sous-type et nom de l'objet
Offset: offset in the space
AG: ID du groupe d'activation
Pointeur système: SYP:Context :Object :Auth :Index :AG
Context: type, sous-type et nom du contexte
Objet: type, sous-type et nom de l'objet
Auth: authority
Index: Index associé au pointeur
AG: ID groupe d'activation
Pointeur d'appel: IVP:Index :AG
Index: Index associé au pointeur
AG: ID groupe d'activation
Pointeur de procédure: PRP:Index :AG
Index: Index associé au pointeur
AG: ID groupe d'activation
Pointeur d'interruption: SUP:Index :AG
Index: Index associé au pointeur
AG: ID groupe d'activation
Pointeur de données: DTP:Index :AG
Index: Index associé au pointeur
AG: ID groupe d'activation
Pointeur de libellé: LBP:Index :AG
Index: Index associé au pointeur
AG: ID groupe d'activation
Pointeur NULL: NULL
- Si un pointeur est imprimé et numérisé à partir du même groupe d'activation, le pointeur numérisé sera comparé au pointeur imprimé.
- Si une fonction de la famille
scanf()analyse un pointeur qui a été imprimé par un autre groupe d'activation, la fonction de la famillescanf()définit le pointeur sur NULL. - Si un pointeur est imprimé dans un environnement à espace mémoire à téraoctets, seule la valeur hexadécimale du pointeur est imprimée. Ces résultats sont identiques à ceux obtenus lors de l'utilisation de%#p.
Le spécificateur de format%#p offre de bien meilleures performances que le spécificateur de format %p.
Pour plus d'informations sur l'utilisation des pointeurs IBM i , voir ILE C/C++ Programmer's Guide .
Si une valeur à virgule flottante INFINITY ou Not-a-Number (NaN) est formatée au format a, e, f ou g, la chaîne de sortie estinfinityounan. Si une valeur à virgule flottante INFINITY ou Not-A-Number (NaN) est formatée au format A, E, F ou G, la chaîne de sortie estINFINITYouNAN.
Les caractères flag et leurs significations sont les suivants (notez que plusieurs flag peuvent apparaître dans une spécification de format):
| Indicateur | Signification | Par défaut |
|---|---|---|
| - | Gauche-Justifier le résultat dans la largeur de la zone. | Justification à droite. |
| + | Préfixez la valeur de sortie avec un signe (+ ou-) si la valeur de sortie est de type signé. | Le signe apparaît uniquement pour les valeurs signées négatives (-). |
| vide('') | Préfixez la valeur de sortie avec un blanc si la valeur de sortie est signée et positive. L'indicateur + remplace l'indicateur vide si les deux apparaissent, et une valeur signée positive sera générée avec un signe. | Aucun blanc. |
| # | Lorsqu'il est utilisé avec les formats o, xou X , l'indicateur # préfixe toute valeur de sortie non nulle avec 0, 0x ou 0X, respectivement. | Aucun préfixe. |
| Lorsqu'il est utilisé avec les formats D (n, p), a, A, e, E, f ou F , l'indicateur # force la valeur de sortie à contenir un séparateur décimal dans tous les cas. | Le séparateur décimal apparaît uniquement si des chiffres le suivent. | |
| Lorsqu'il est utilisé avec les formats g ou G , l'indicateur # force la valeur de sortie à contenir un séparateur décimal dans tous les cas et empêche la troncature des zéros de fin. | Le séparateur décimal apparaît uniquement si des chiffres le suivent ; les zéros de fin sont tronqués. | |
| Lorsqu'il est utilisé avec le format ls ou S, l'indicateur # permet de mesurer la précision en caractères, quelle que soit la taille du caractère. Par exemple, si des caractères mono-octet sont imprimés, une précision de 4 entraîne l'impression de 4 octets. Si des caractères codés sur deux octets sont imprimés, une précision de 4 entraîne l'impression de 8 octets. | La précision indique le nombre maximal d'octets à générer. | |
| Lorsqu'il est utilisé avec le format p , l'indicateur # convertit le pointeur en chiffres hexadécimaux. Ces chiffres hexadécimaux ne peuvent pas être reconvertis en pointeur, sauf dans un environnement à espace mémoire à téraoctets. | Pointeur converti en une séquence de caractères imprimables. | |
| 0 | Lorsqu'il est utilisé avec les formats d, i, D (n, p) o, u, x, X, a, A, e, E, f, F, gou G , l'indicateur 0 provoque le remplissage de la sortie par 0pour la largeur du champ. L'indicateur 0 est ignoré si la précision est spécifiée pour un entier ou si l'indicateur - est spécifié. | Remplissage de l'espace. Pas de remplissage d'espace pour D (n, p). |
L'indicateur # ne doit pas être utilisé avec les types c, lc, d, i, uou s .
Largeur est un entier décimal non négatif qui contrôle le nombre minimal de caractères imprimés. Si le nombre de caractères (octets) dans la valeur de sortie est inférieur à la largeurspécifiée, des blancs sont ajoutés à gauche ou à droite (selon que l'indicateur - est spécifié) jusqu'à ce que la largeur minimale soit atteinte.
Largeur n'entraîne jamais la troncature d'une valeur ; si le nombre de caractères (octets) dans la valeur de sortie est supérieur à la largeurspécifiée ou si largeur n'est pas indiqué, tous les caractères de la valeur sont imprimés (conformément à la spécification precision ).
Pour le type ls ou S, width est spécifié en octets. Si le nombre d'octets dans la valeur de sortie est inférieur à la largeur spécifiée, des blancs à un octet sont ajoutés à gauche ou à droite (selon que l'indicateur - est spécifié) jusqu'à ce que la largeur minimale soit atteinte.
La spécification width peut être un astérisque (*), auquel cas un argument de la liste d'arguments fournit la valeur. L'argument width doit précéder la valeur formatée dans la liste des arguments.
Précision est un entier décimal non négatif précédé d'un point, qui indique le nombre de caractères à imprimer ou le nombre de décimales. Contrairement à la spécification width , la précision peut entraîner la troncature de la valeur de sortie ou l'arrondi d'une valeur à virgule flottante ou d'une valeur décimale condensée .
La spécification precision peut être un astérisque (*), auquel cas un argument de la liste d'arguments fournit la valeur. L'argument precision doit précéder la valeur formatée dans la liste des arguments.
L'interprétation de la valeur precision et de la valeur par défaut lorsque la précision est omise dépend du type, comme illustré dans le tableau suivant:
| Type | Signification | Par défaut |
|---|---|---|
A |
Pour les nombres à virgule flottante non décimale, précision indique le nombre de chiffres hexadécimaux à imprimer après le séparateur décimal. Pour les nombres à virgule flottante décimale, précision indique le nombre de chiffres significatifs à imprimer. |
Pour les nombres à virgule flottante non décimale, la précision par défaut est suffisante pour une représentation exacte de la valeur. Si la précision est 0, aucun séparateur décimal n'est imprimé. Pour les nombres décimaux à virgule flottante, la précision par défaut est suffisante pour une représentation exacte de la valeur. Pour plus de détails sur le format utilisé, voir Tableau 1 . |
i
d u o x X |
Précision indique le nombre minimal de chiffres à imprimer. Si le nombre de chiffres dans l'argument est inférieur à la précision, la valeur de sortie est complétée à gauche par des zéros. La valeur n'est pas tronquée lorsque le nombre de chiffres dépasse la précision. | Si la précision est 0 ou omise entièrement, ou si le point (.) apparaît sans nombre après lui, la précision est définie sur 1. |
f
F D (n, p) e E |
Précision indique le nombre de chiffres à imprimer après le séparateur décimal. Le dernier chiffre imprimé est arrondi. | La précision par défaut pour f, F, e et E est six. La précision par défaut pour D (n, p) est p. Si la précision est 0 ou si le point apparaît sans nombre, aucun séparateur décimal n'est imprimé. |
g
G |
Précision indique le nombre maximal de chiffres significatifs imprimés. | Tous les chiffres significatifs sont imprimés. La valeur par défaut de précision est six. |
c
|
Aucun effet. | Le caractère est imprimé. |
lc
|
Aucun effet. | Le caractère wchar_t est converti et le caractère multioctet résultant est imprimé. |
s
|
Précision indique le nombre maximal de caractères (octets) à imprimer. Les caractères (octets) dépassant la précision ne sont pas imprimés. | Les caractères sont imprimés jusqu'à ce qu'un caractère null soit rencontré. |
ls
|
Précision indique le nombre maximal d'octets à imprimer. Les octets dépassant la précision ne sont pas imprimés ; toutefois, l'intégrité multioctet est toujours préservée. | Les caractères wchar_t sont convertis et les caractères multi-octets qui en résultent sont imprimés. |
Valeur renvoyée
printf() renvoie le nombre d'octets imprimés. La valeur de errno peut être définie sur:- Valeur
- Signification
- MODE d'EBAD
- Le mode de fichier indiqué n'est pas valide.
- CONVERT
- Une erreur de conversion s'est produite.
- ERREUR D'E-S
- Une erreur d'E-S irrémédiable s'est produite.
- EIORECERR
- Une erreur d'E-S remédiable s'est produite.
- EILSEQ
- Une séquence de caractères multi-octets non valide a été détectée.
- EPUTANDGET
- Une opération d'écriture interdite s'est produite après une opération de lecture.
- ESTDOUT
stdoutne peut pas être ouvert.
printf() est sensible à l'environnement local. Le caractère de base est le séparateur décimal à utiliser pour le caractère # du paramètre de chaîne de format pour les types de format D (n, p), a, A, e, E, f, F, g et G.Exemples
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char ch = 'h', *string = "computer";
int count = 234, hex = 0x10, oct = 010, dec = 10;
double fp = 251.7366;
wchar_t wc = (wchar_t)0x0058;
wchar_t ws[4];
printf("1234567890123%n4567890123456789\n\n", &count);
printf("Value of count should be 13; count = %d\n\n", count);
printf("%10c%5c\n", ch, ch);
printf("%25s\n%25.4s\n\n", string, string);
printf("%f %.2f %e %E\n\n", fp, fp, fp, fp);
printf("%i %i %i\n\n", hex, oct, dec);
}
/***************** Output should be similar to: *****************
234 +234 000234 EA ea 352
12345678901234567890123456789
Value of count should be 13; count = 13
h h
computer
comp
251.736600 251.74 2.517366e+02 2.517366E+02
16 8 10
*******************************************************************/ Exemple utilisant printf()
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
/* This program is compiled with LOCALETYPE(*LOCALEUCS2) and */
/* SYSIFCOPT(*IFSIO) */
/* We will assume the locale setting is the same as the CCSID of the */
/* job. We will also assume any files involved have a CCSID of */
/* 65535 (no convert). This way if printf goes to the screen or */
/* a file the output will be the same. */
int main(void)
{
wchar_t wc = 0x0058; /* UNICODE X */
wchar_t ws[4];
setlocale(LC_ALL,
"/QSYS.LIB/EN_US.LOCALE"); /* a CCSID 37 locale */
ws[0] = 0x0041; /* UNICODE A */
ws[1] = (wchar_t)0x0042; /* UNICODE B */
ws[2] = (wchar_t)0x0043; /* UNICODE C */
ws[3] = (wchar_t)0x0000;
/* The output displayed is CCSID 37 */
printf("%lc %ls\n\n",wc,ws);
printf("%lc %.2ls\n\n",wc,ws);
/* Now let's try a mixed-byte CCSID example */
/* You would need a device that can handle mixed bytes to */
/* display this correctly. */
setlocale(LC_ALL,
"/QSYS.LIB/JA_JP.LOCALE");/* a CCSID 5026 locale */
/* big A means an A that takes up 2 bytes on the screen */
/* It will look bigger then single byte A */
ws[0] = (wchar_t)0xFF21; /* UNICODE big A */
ws[1] = (wchar_t)0xFF22; /* UNICODE big B */
ws[2] = (wchar_t)0xFF23; /* UNICODE big C */
ws[3] = (wchar_t)0x0000;
wc = 0xff11; /* UNICODE big 1 */
printf("%lc %ls\n\n",wc,ws);
/* The output of this printf is not shown below and it */
/* will differ depending on the device you display it on,*/
/* but if you looked at the string in hex it would look */
/* like this: 0E42F10F404040400E42C142C242C30F */
/* 0E is shift out, 0F is shift in, and 42F1 is the */
/* big 1 in CCSID 5026 */
printf("%lc %.4ls\n\n",wc,ws);
/* The output of this printf is not shown below either. */
/* The hex would look like: */
/* 0E42F10F404040400E42C10F */
/* Since the precision is in bytes we only get 4 bytes */
/* of the string. */
printf("%lc %#.2ls\n\n",wc,ws);
/* The output of this printf is not shown below either. */
/* The hex would look like: */
/* 0E42F10F404040400E42C142C20F */
/* The # means precision is in characters reguardless */
/* of size. So we get 2 characters of the string. */
}
/***************** Output should be similar to: *****************
X ABC
X AB
*******************************************************************/
Exemple utilisant printf()
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
/* This program is compile LOCALETYPE(*LOCALE) and */
/* SYSIFCOPT(*IFSIO) */
int main(void)
{
wchar_t wc = (wchar_t)0x00C4; /* D */
wchar_t ws[4];
ws[0] = (wchar_t)0x00C1; /* A */
ws[1] = (wchar_t)0x00C2; /* B */
ws[2] = (wchar_t)0x00C3; /* C */
ws[3] = (wchar_t)0x0000;
/* The output displayed is CCSID 37 */
printf("%lc %ls\n\n",wc,ws);
/* Now let's try a mixed-byte CCSID example */
/* You would need a device that can handle mixed bytes to */
/* display this correctly. */
setlocale(LC_ALL,
"/QSYS.LIB/JA_JP.LOCALE"); /* a CCSID 5026 locale */
/* big A means an A that takes up 2 bytes on the screen */
/* It will look bigger than single byte A */
ws[0] = (wchar_t)0x42C1; /* big A */
ws[1] = (wchar_t)0x42C2; /* big B */
ws[2] = (wchar_t)0x42C3; /* big C */
ws[3] = (wchar_t)0x0000;
wc = 0x42F1; /* big 1 */
printf("%lc %ls\n\n",wc,ws);
/* The output of this printf is not shown below and it */
/* will differ depending on the device you display it on,*/
/* but if you looked at the string in hex it would look */
/* like this: 0E42F10F404040400E42C142C242C30F */
/* 0E is shift out, 0F is shift in, and 42F1 is the */
/* big 1 in CCSID 5026 */
printf("%lc %.4ls\n\n",wc,ws);
/* The output of this printf is not shown below either. */
/* The hex would look like: */
/* 0E42F10F404040400E42C10F */
/* Since the precision is in bytes we only get 4 bytes */
/* of the string. */
printf("%lc %#.2ls\n\n",wc,ws);
/* The output of this printf is not shown below either. */
/* The hex would look like: */
/* 0E42F10F404040400E42C142C20F */
/* The # means precision is in characters regardless */
/* of size. So we get 2 characters of the string. */
}
/***************** Output should be similar to: *****************
D ABC
*******************************************************************/
Rubriques connexes
- fprintf ()-Ecrire des données formatées dans un flux
- fscanf ()-Lecture de données formatées
- quantexpd32()- quantexpd64()- quantexpd128()-Calcule l'exposant quantique
- scanf ()-Lecture de données
- sprintf ()-Impression des données formatées dans la mémoire tampon
- sscanf ()-Lecture de données
- vfprintf ()-Impression des données de l'argument dans le flux
- vprintf ()-Imprimer les données de l'argument
- vsprintf ()-Impression des données de l'argument dans la mémoire tampon
- wprintf ()-Mise en forme des données sous forme de caractères larges et impression
- <stdio.h>