Come si può stampare una variabile size_t in modo portabile usando la famiglia printf?

Ho una variabile di tipo size_te voglio stamparla usando printf(). Quale identificatore di formato devo usare per stamparlo in modo portabile?

Nella macchina a 32 bit, %usembra giusto. Ho compilato g++ -g -W -Wall -Werror -ansi -pedantice non ci sono stati avvisi. Ma quando compilo quel codice in una macchina a 64 bit, viene generato un avviso.

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'avvertimento scompare, come previsto, se lo cambio a %lu.

La domanda è: come posso scrivere il codice, in modo che venga compilato senza avvisi su macchine a 32 e 64 bit?

Modifica: Per ovviare al problema, suppongo che una risposta potrebbe essere quella di "trasmettere" la variabile in un numero intero abbastanza grande, diciamo unsigned long, e stamparlo usando %lu. Funzionerebbe in entrambi i casi. Sto cercando se c'è qualche altra idea.

Usa il zmodificatore:

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

Sembra che varia a seconda del compilatore che stai utilizzando (blech):

• dice gnu%zu (o %zx, o %zdma che lo mostra come se fosse firmato, ecc.)
• Microsoft dice%Iu (o %Ix, o %Idancora, che è firmato, ecc.) - ma a partire da cl v19 (in Visual Studio 2015), Microsoft supporta %zu (vedi questa risposta a questo commento )

... e ovviamente, se usi C ++, puoi usare coutinvece come suggerito da AraK .

Per C89, utilizzare %lue trasmettere il valore per unsigned long:

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

Per C99 e versioni successive, utilizzare %zu:

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

Estensione della risposta di Adam Rosenfield per Windows.

Ho testato questo codice con sia su VS2013 Update 4 che su 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;
}

VS2015 generato uscite binarie:

1
1
2

mentre quello generato da VS2013 dice:

zu
zx
zd

Nota: ssize_tè un'estensione POSIX ed SSIZE_Tè simile nei tipi di dati di Windows , quindi ho aggiunto un <BaseTsd.h>riferimento.

Inoltre, ad eccezione delle seguenti intestazioni C99 / C11, tutte le intestazioni C99 sono disponibili nell'anteprima VS2015:

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

Inoltre, C11 <uchar.h>è ora incluso nell'ultima anteprima.

Per ulteriori dettagli, vedere questo vecchio e il nuovo elenco per la conformità standard.

Per coloro che parlano di farlo in C ++ che non supporta necessariamente le estensioni C99, allora consiglio vivamente boost :: format. Questo rende discutibile la domanda sulla dimensione del tipo size_t:

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

Poiché non hai bisogno di identificatori di dimensione in formato boost ::, puoi solo preoccuparti di come visualizzare il valore.

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

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

Come ha detto AraK, l'interfaccia di flussi c ++ funzionerà sempre in modo portabile.

std :: size_t s = 1024; std :: cout << s; // o qualsiasi altro tipo di stream come stringstream!

Se si desidera C stdio, non esiste una risposta portatile a questa in alcuni casi di "portatile". E diventa brutto da quando hai visto, scegliere i flag di formato errati può produrre un avviso del compilatore o fornire un output errato.

C99 ha provato a risolvere questo problema con formati inttypes.h come "%" PRIdMAX "\ n". Ma proprio come con "% zu", non tutti supportano c99 (come MSVS prima del 2013). Ci sono file "msinttypes.h" che fluttuano intorno per risolvere questo problema.

Se si esegue il cast di un tipo diverso, a seconda dei flag, è possibile che venga visualizzato un avviso del compilatore per il troncamento o una modifica del segno. Se segui questo percorso, scegli un tipo di dimensione fissa rilevante più grande. Uno di unsigned long long e "% llu" o unsigned long "% lu" dovrebbe funzionare, ma llu può anche rallentare le cose in un mondo a 32 bit eccessivamente grande. (Modifica: il mio mac emette un avviso a 64 bit per% llu che non corrisponde a size_t, anche se% lu,% llu e size_t hanno tutte le stesse dimensioni. E% lu e% llu non hanno le stesse dimensioni sul mio MSVS2012. potrebbe essere necessario eseguire il cast + utilizzare un formato corrispondente.)

In questo caso, puoi scegliere tipi di dimensioni fisse, come int64_t. Ma aspetta! Ora torniamo a c99 / c ++ 11 e MSVS precedente fallisce di nuovo. Inoltre hai anche cast (ad esempio map.size () non è un tipo di dimensione fissa)!

Puoi utilizzare un'intestazione o una libreria di terze parti come boost. Se non ne stai già utilizzando uno, potresti non voler gonfiare il tuo progetto in quel modo. Se sei disposto ad aggiungerne uno solo per questo problema, perché non utilizzare flussi c ++ o compilazione condizionale?

Quindi sei impegnato in flussi c ++, compilazione condizionale, framework di terze parti o qualcosa di portatile che sembra funzionare per te.

Ti avvertirà se passi un numero intero senza segno a 32 bit in un formato% lu? Dovrebbe andare bene poiché la conversione è ben definita e non perde alcuna informazione.

Ho sentito che alcune piattaforme definiscono le macro <inttypes.h>che puoi inserire nel formato string letterale ma non vedo quell'intestazione sul mio compilatore Windows C ++, il che implica che potrebbe non essere multipiattaforma.

C99 definisce "% zd" ecc. Per questo. (grazie ai commentatori) Non esiste un identificatore di formato portatile per questo in C ++: è possibile utilizzare la %pparola woulkd in questi due scenari, ma non è nemmeno una scelta portatile e fornisce il valore in esadecimale.

In alternativa, utilizzare alcuni streaming (ad esempio stringstream) o una sostituzione di stampa sicura come Boost Format . Comprendo che questo consiglio ha solo un uso limitato (e richiede C ++). (Abbiamo implementato un approccio simile adatto alle nostre esigenze durante l'implementazione del supporto Unicode.)

Il problema fondamentale per C è che printf usando i puntini di sospensione non è sicuro in base alla progettazione: deve determinare la dimensione dell'argomento aggiuntivo dagli argomenti noti, quindi non può essere riparato per supportare "qualunque cosa tu abbia". Quindi, a meno che il compilatore non abbia implementato alcune estensioni proprietarie, sei sfortunato.

Su alcune piattaforme e per alcuni tipi sono disponibili specifici identificatori di conversione printf, ma a volte è necessario ricorrere al casting per tipi più grandi.

Ho documentato questo delicato problema qui, con il codice di esempio: http://www.pixelbeat.org/programming/gcc/int_types/ e lo aggiorno periodicamente con informazioni su nuove piattaforme e tipi.

se vuoi stampare il valore di size_t come stringa puoi farlo:

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);

il risultato è:

numero: 2337200120702199116

testo: Andiamo a pescare invece di sederci sul nostro ma !!

Modifica: rileggere la domanda a causa dei voti negativi ho notato che il suo problema non è% llu o% I64d ma il tipo size_t su macchine diverse vede questa domanda https://stackoverflow.com/a/918909/1755797
http: // www. cplusplus.com/reference/cstdio/printf/

size_t è unsigned int su una macchina a 32 bit e unsigned long long int su 64bit
ma% ll si aspetta sempre un unsigned long long int.

size_t varia in lunghezza su diversi sistemi operativi mentre% llu è lo stesso