Comment imprimer une variable size_t de manière portable en utilisant la famille printf?

J'ai une variable de type size_tet je veux l'imprimer en utilisant printf(). Quel spécificateur de format dois-je utiliser pour l'imprimer de manière portable?

Dans une machine 32 bits, %usemble juste. J'ai compilé avec g++ -g -W -Wall -Werror -ansi -pedantic, et il n'y a eu aucun avertissement. Mais quand je compile ce code sur une machine 64 bits, il produit un avertissement.

size_t x = <something>;
printf("size = %u\n", x);

warning: format '%u' expects type 'unsigned int', 
    but argument 2 has type 'long unsigned int'

L'avertissement disparaît, comme prévu, si je change cela en %lu.

La question est, comment puis-je écrire le code, afin qu'il compile sans avertissement sur les machines 32 et 64 bits?

Edit: Comme solution de contournement, je suppose qu'une réponse pourrait être de "convertir" la variable en un entier suffisamment grand, par exemple unsigned long, et d'imprimer à l'aide %lu. Cela fonctionnerait dans les deux cas. Je cherche s'il y a une autre idée.

Utilisez le zmodificateur:

size_t x = ...;
ssize_t y = ...;
printf("%zu\n", x);  // prints as unsigned decimal
printf("%zx\n", x);  // prints as hex
printf("%zd\n", y);  // prints as signed decimal

Il semble que cela varie en fonction du compilateur que vous utilisez (blech):

• gnu dit%zu (ou %zx, ou %zdmais cela l'affiche comme s'il était signé, etc.)
• Microsoft dit%Iu (ou %Ix, ou %Idmais c'est signé, etc.) - mais à partir de cl v19 (dans Visual Studio 2015), Microsoft prend en charge %zu (voir cette réponse à ce commentaire )

... et bien sûr, si vous utilisez C ++, vous pouvez utiliser à la coutplace comme suggéré par AraK .

Pour C89, utilisez %luet convertissez la valeur en unsigned long:

size_t foo;
...
printf("foo = %lu\n", (unsigned long) foo);

Pour C99 et versions ultérieures, utilisez %zu:

size_t foo;
...
printf("foo = %zu\n", foo);

Prolongeant la réponse d'Adam Rosenfield pour Windows.

J'ai testé ce code avec à la fois sur VS2013 Update 4 et VS2015 preview:

// test.c

#include <stdio.h>
#include <BaseTsd.h> // see the note below

int main()
{
    size_t x = 1;
    SSIZE_T y = 2;
    printf("%zu\n", x);  // prints as unsigned decimal
    printf("%zx\n", x);  // prints as hex
    printf("%zd\n", y);  // prints as signed decimal
    return 0;
}

Sorties binaires générées par VS2015:

1
1
2

tandis que celui généré par VS2013 dit:

zu
zx
zd

Remarque: ssize_test une extension POSIX et SSIZE_Test une chose similaire dans les types de données Windows , d'où j'ai ajouté une <BaseTsd.h>référence.

De plus, à l'exception des en-têtes C99 / C11 suivants, tous les en-têtes C99 sont disponibles dans l'aperçu VS2015:

C11 - <stdalign.h>
C11 - <stdatomic.h>
C11 - <stdnoreturn.h>
C99 - <tgmath.h>
C11 - <threads.h>

De plus, les C11 <uchar.h>sont désormais inclus dans le dernier aperçu.

Pour plus de détails, consultez cette ancienne et la nouvelle liste pour la conformité standard.

Pour ceux qui parlent de faire cela en C ++ qui ne prend pas nécessairement en charge les extensions C99, je recommande vivement boost :: format. Cela rend la question de taille de type size_t théorique:

std::cout << boost::format("Sizeof(Var) is %d\n") % sizeof(Var);

Comme vous n'avez pas besoin de spécificateurs de taille au format boost ::, vous pouvez simplement vous soucier de la façon dont vous souhaitez afficher la valeur.

std::size_t s = 1024;
std::cout << s; // or any other kind of stream like stringstream!

printf("size = %zu\n", sizeof(thing) );

Comme l'a dit AraK, l'interface des flux c ++ fonctionnera toujours de manière portable.

std :: size_t s = 1024; std :: cout << s; // ou tout autre type de flux comme stringstream!

Si vous voulez C stdio, il n'y a pas de réponse portable à cela pour certains cas de "portable". Et cela devient moche car, comme vous l'avez vu, choisir les mauvais indicateurs de format peut générer un avertissement du compilateur ou donner une sortie incorrecte.

C99 a essayé de résoudre ce problème avec des formats inttypes.h comme "%" PRIdMAX "\ n". Mais tout comme avec "% zu", tout le monde ne prend pas en charge c99 (comme MSVS avant 2013). Il y a des fichiers "msinttypes.h" qui flottent pour gérer cela.

Si vous effectuez un cast vers un type différent, selon les indicateurs, vous pouvez obtenir un avertissement du compilateur pour la troncature ou un changement de signe. Si vous suivez cette route, choisissez un type de taille fixe pertinent plus grand. L'un des longs non signés et "% llu" ou des longs "% lu" non signés devrait fonctionner, mais llu peut également ralentir les choses dans un monde 32 bits comme excessivement grand. (Modifier - mon mac émet un avertissement en 64 bits pour% llu ne correspondant pas à size_t, même si% lu,% llu et size_t sont tous de la même taille. Et% lu et% llu ne sont pas de la même taille sur mon MSVS2012. Donc vous devrez peut-être caster + utiliser un format qui correspond.)

Pour cette question, vous pouvez aller avec des types de taille fixe, tels que int64_t. Mais attendez! Maintenant, nous sommes de retour à c99 / c ++ 11, et les anciens MSVS échouent à nouveau. De plus, vous avez également des moulages (par exemple map.size () n'est pas un type de taille fixe)!

Vous pouvez utiliser un en-tête ou une bibliothèque tiers tel que boost. Si vous n'en utilisez pas déjà un, vous ne voudrez peut-être pas gonfler votre projet de cette façon. Si vous êtes prêt à en ajouter un juste pour ce problème, pourquoi ne pas utiliser des flux c ++ ou une compilation conditionnelle?

Donc, vous en êtes aux flux c ++, à la compilation conditionnelle, aux frameworks tiers ou à quelque chose de portable qui vous convient.

Vous avertira-t-il si vous passez un entier non signé 32 bits au format% lu? Cela devrait être bien car la conversion est bien définie et ne perd aucune information.

J'ai entendu dire que certaines plates-formes définissent des macros en ce <inttypes.h>que vous pouvez insérer dans le littéral de chaîne de format, mais je ne vois pas cet en-tête sur mon compilateur Windows C ++, ce qui implique qu'il ne peut pas être multiplateforme.

C99 définit "% zd" etc. pour cela. (Merci aux commentateurs) Il n'y a pas de spécificateur de format portable pour cela en C ++ - vous pouvez utiliser %pce mot qui dans les deux scénarios, mais ce n'est pas un choix portable non plus, et donne la valeur en hexadécimal.

Alternativement, utilisez un streaming (par exemple stringstream) ou un remplacement de printf sûr tel que Boost Format . Je comprends que ce conseil n'est que d'une utilité limitée (et nécessite C ++). (Nous avons utilisé une approche similaire adaptée à nos besoins lors de l'implémentation de la prise en charge unicode.)

Le problème fondamental pour C est que printf utilisant des points de suspension est dangereux par conception - il doit déterminer la taille de l'argument supplémentaire à partir des arguments connus, il ne peut donc pas être corrigé pour prendre en charge "tout ce que vous avez". Donc, à moins que votre compilateur implémente des extensions propriétaires, vous n'avez pas de chance.

Sur certaines plates-formes et pour certains types, des spécificateurs de conversion printf spécifiques sont disponibles, mais il faut parfois recourir à la conversion vers des types plus grands.

J'ai documenté ce problème délicat ici, avec un exemple de code: http://www.pixelbeat.org/programming/gcc/int_types/ et le mettre à jour périodiquement avec des informations sur de nouvelles plates-formes et types.

si vous souhaitez imprimer la valeur d'un size_t sous forme de chaîne, vous pouvez le faire:

char text[] = "Lets go fishing in stead of sitting on our but !!";
size_t line = 2337200120702199116;

/* on windows I64x or I64d others %lld or %llx if it works %zd or %zx */
printf("number: %I64d\n",*(size_t*)&text);
printf("text: %s\n",*(char(*)[])&line);

le résultat est:

numéro: 2337200120702199116

texte: Allons pêcher au lieu de s'asseoir sur notre mais !!

Edit: relisant la question en raison des votes négatifs, j'ai remarqué que son problème n'est pas% llu ou% I64d mais le type size_t sur différentes machines voir cette question https://stackoverflow.com/a/918909/1755797
http: // www. cplusplus.com/reference/cstdio/printf/

size_t est entier non signé sur une machine 32 bits et entier long long non signé sur 64 bits
mais% ll attend toujours un entier long long non signé.

size_t varie en longueur sur différents systèmes d'exploitation tandis que% llu est le même