C Language
Entrée / sortie formatée

Impression de la valeur d'un pointeur sur un objet

Pour imprimer la valeur d'un pointeur sur un objet (par opposition à un pointeur de fonction), utilisez le spécificateur de conversion p . Il est défini pour imprimer uniquement les pointeurs void , donc pour imprimer la valeur d'un pointeur non void il doit être explicitement converti ("casted *") en void* .

#include <stdlib.h> /* for EXIT_SUCCESS */
#include <stdio.h>  /* for printf() */

int main(void)
{
  int i;
  int * p = &i;

  printf("The address of i is %p.\n", (void*) p);

  return EXIT_SUCCESS;
}

#include <inttypes.h> /* for uintptr_t and PRIXPTR */
#include <stdio.h>    /* for printf() */

int main(void)
{
  int  i;
  int *p = &i;

  printf("The address of i is 0x%" PRIXPTR ".\n", (uintptr_t)p);

  return 0;
}

#include <stdio.h> /* optional in pre-standard C - for printf() */

int main()
{
  int  i;
  int *p = &i;

  printf("The address of i is 0x%lx.\n", (long unsigned) p);

  return 0;
}

Impression de la différence des valeurs de deux pointeurs sur un objet

Soustraire les valeurs de deux pointeurs à un objet donne un entier signé ^{* 1} . Donc, il serait imprimé en utilisant au moins le spécificateur de conversion d .

Pour vous assurer qu'il existe un type suffisamment large pour contenir une telle "différence de pointeur", puisque C99 <stddef.h> définit le type ptrdiff_t . Pour imprimer un ptrdiff_t utilisez le modificateur de longueur t .

#include <stdlib.h> /* for EXIT_SUCCESS */
#include <stdio.h> /* for printf() */
#include <stddef.h> /* for ptrdiff_t */


int main(void)
{
  int a[2];
  int * p1 = &a[0], * p2 = &a[1];
  ptrdiff_t pd = p2 - p1;

  printf("p1 = %p\n", (void*) p1);
  printf("p2 = %p\n", (void*) p2);
  printf("p2 - p1 = %td\n", pd);

  return EXIT_SUCCESS;
}

p1 = 0x7fff6679f430
p2 = 0x7fff6679f434
p2 - p1 = 1

Spécificateurs de conversion pour l'impression

Noter que les modificateurs de longueur peuvent être appliqués à %n (par exemple, %hhn indique qu'un spécificateur de conversion n suivant s'applique à un pointeur sur un argument de caractère signed char , conformément à la norme ISO / IEC 9899: 2011, § 7.21.6.1 ¶7).

Notez que les conversions à virgule flottante appliquées aux types float et double raison de règles de promotion par défaut - §6.5.2.2 Appels de fonction, ¶7 La notation par points de suspension dans un déclarant de prototype de fonction entraîne l'arrêt de la conversion après le dernier paramètre déclaré. Les promotions d'argument par défaut sont effectuées sur les arguments de fin. ) Ainsi, les fonctions telles que printf() ne sont transmises qu’à double valeurs double , même si la variable référencée est de type float .

Avec les formats g et G , le choix entre la notation e et f (ou E et F ) est documenté dans le standard C et dans la spécification POSIX pour printf() :

Le double argument représentant un nombre à virgule flottante doit être converti dans le style f ou e (ou dans le style F ou E dans le cas d'un spécificateur de conversion G ), en fonction de la valeur convertie et de la précision. Soit P la précision si elle est égale à zéro, 6 si la précision est omise ou 1 si la précision est égale à zéro. Alors, si une conversion avec le style E aurait un exposant de X :

• Si P> X> = -4, la conversion doit être avec le style f (ou F ) et la précision P - (X+1) .
• Sinon, la conversion doit se faire avec le style e (ou E ) et la précision P - 1 .

Enfin, à moins que le drapeau "#" ne soit utilisé, tous les zéros à la fin seront supprimés de la partie fractionnaire du résultat et le caractère décimal sera supprimé s’il ne reste aucune partie fractionnaire.

La fonction printf ()

Accessible via y compris <stdio.h> , la fonction printf() est l’outil principal utilisé pour imprimer du texte sur la console en C.

printf("Hello world!");
// Hello world!

Les tableaux de caractères normaux et non formatés peuvent être imprimés par eux-mêmes en les plaçant directement entre les parenthèses.

printf("%d is the answer to life, the universe, and everything.", 42);
// 42 is the answer to life, the universe, and everything.

int x = 3;
char y = 'Z';
char* z = "Example";
printf("Int: %d, Char: %c, String: %s", x, y, z);
// Int: 3, Char: Z, String: Example

Vous pouvez également imprimer des nombres entiers, des nombres à virgule flottante, des caractères et autres en utilisant le caractère d'échappement % , suivi d'un caractère ou d'une séquence de caractères indiquant le format, appelé spécificateur de format .

Tous les arguments supplémentaires de la fonction printf() sont séparés par des virgules et ces arguments doivent être dans le même ordre que les spécificateurs de format. Les arguments supplémentaires sont ignorés, tandis que les arguments mal typés ou l'absence d'arguments provoquent des erreurs ou un comportement indéfini. Chaque argument peut être une valeur littérale ou une variable.

Après une exécution réussie, le nombre de caractères imprimés est renvoyé avec le type int . Sinon, un échec renvoie une valeur négative.

Modificateurs de longueur

Les normes C99 et C11 spécifient les modificateurs de longueur suivants pour printf() ; leurs significations sont:

Si un modificateur de longueur apparaît avec un spécificateur de conversion autre que celui spécifié ci-dessus, le comportement est indéfini.

Microsoft spécifie des modificateurs de longueur différents et ne prend pas explicitement en charge hh , j , z ou t .

Notez que les spécificateurs de conversion C , S et Z et les modificateurs de longueur I , I32 , I64 et w sont des extensions Microsoft. Traiter l comme un modificateur du long double plutôt que du double est différent du standard, mais vous aurez du mal à repérer la différence à moins que le long double ait une représentation différente du double .

Drapeaux de format d'impression

Le standard C (C11 et C99) définit les indicateurs suivants pour printf() :

Ces indicateurs sont également pris en charge par Microsoft avec les mêmes significations.

La spécification POSIX pour printf() ajoute: