Pulisci il codice per printf size_t in C ++ (o: equivalente più vicino a% z di C99 in C ++)

Ho del codice C ++ che stampa un size_t:

size_t a;
printf("%lu", a);

Mi piacerebbe che questo si compilasse senza avvisi su entrambe le architetture a 32 e 64 bit.

Se questo fosse C99, potrei usare printf("%z", a);. Ma AFAICT %znon esiste in nessun dialetto C ++ standard. Quindi, invece, devo fare

printf("%lu", (unsigned long) a);

che è davvero brutto.

Se non ci sono funzionalità per la stampa di size_ts incorporate nel linguaggio, mi chiedo se sia possibile scrivere un wrapper printf o qualcosa di simile che inserirà i cast appropriati su size_ts in modo da eliminare gli avvisi del compilatore spuri pur mantenendo quelli buoni.

Qualche idea?

La maggior parte dei compilatori ha i propri specificatori size_te ptrdiff_targomenti, Visual C ++ ad esempio usa rispettivamente% Iu e% Id, penso che gcc ti permetterà di usare% zu e% zd.

Potresti creare una macro:

#if defined(_MSC_VER) || defined(__MINGW32__) //__MINGW32__ should goes before __GNUC__
  #define JL_SIZE_T_SPECIFIER    "%Iu"
  #define JL_SSIZE_T_SPECIFIER   "%Id"
  #define JL_PTRDIFF_T_SPECIFIER "%Id"
#elif defined(__GNUC__)
  #define JL_SIZE_T_SPECIFIER    "%zu"
  #define JL_SSIZE_T_SPECIFIER   "%zd"
  #define JL_PTRDIFF_T_SPECIFIER "%zd"
#else
  // TODO figure out which to use.
  #if NUMBITS == 32
    #define JL_SIZE_T_SPECIFIER    something_unsigned
    #define JL_SSIZE_T_SPECIFIER   something_signed
    #define JL_PTRDIFF_T_SPECIFIER something_signed
  #else
    #define JL_SIZE_T_SPECIFIER    something_bigger_unsigned
    #define JL_SSIZE_T_SPECIFIER   something_bigger_signed
    #define JL_PTRDIFF_T_SPECIFIER something-bigger_signed
  #endif
#endif

Utilizzo:

size_t a;
printf(JL_SIZE_T_SPECIFIER, a);
printf("The size of a is " JL_SIZE_T_SPECIFIER " bytes", a);

L' printfidentificatore di formato %zufunzionerà bene sui sistemi C ++; non è necessario renderlo più complicato.

C ++ 11

C ++ 11 importa C99 quindi std::printfdovrebbe supportare l'identificatore di %zuformato C99 .

C ++ 98

Sulla maggior parte delle piattaforme size_te uintptr_tsono equivalenti, nel qual caso è possibile utilizzare la PRIuPTRmacro definita in <cinttypes>:

size_t a = 42;
printf("If the answer is %" PRIuPTR " then what is the question?\n", a);

Se vuoi davvero essere al sicuro, trasmetti uintmax_te usa PRIuMAX:

printf("If the answer is %" PRIuMAX " then what is the question?\n", static_cast<uintmax_t>(a));

In Windows e nell'implementazione di Visual Studio di printf

 %Iu

per me va bene. vedi msdn

Dato che stai usando C ++, perché non usare IOStreams? Dovrebbe compilarsi senza avvertimenti e fare la cosa giusta in grado di riconoscere i tipi, purché non si utilizzi un'implementazione C ++ cerebrale che non definisce un file operator <<for size_t.

Quando l'output effettivo deve essere eseguito printf(), puoi comunque combinarlo con IOStreams per ottenere un comportamento indipendente dai tipi:

size_t foo = bar;
ostringstream os;
os << foo;
printf("%s", os.str().c_str());

Non è super efficiente, ma il tuo caso sopra riguarda l'I / O di file, quindi questo è il tuo collo di bottiglia, non questo codice di formattazione della stringa.

ecco una possibile soluzione, ma non è proprio carina ..

template< class T >
struct GetPrintfID
{
  static const char* id;
};

template< class T >
const char* GetPrintfID< T >::id = "%u";


template<>
struct GetPrintfID< unsigned long long > //or whatever the 64bit unsigned is called..
{
  static const char* id;
};

const char* GetPrintfID< unsigned long long >::id = "%lu";

//should be repeated for any type size_t can ever have


printf( GetPrintfID< size_t >::id, sizeof( x ) );

La libreria fmt fornisce un'implementazione veloce e portabile (e sicura) che printfinclude il zmodificatore per size_t:

#include "fmt/printf.h"

size_t a = 42;

int main() {
  fmt::printf("%zu", a);
}

In aggiunta a ciò, supporta la sintassi della stringa di formato simile a Python e acquisisce le informazioni sul tipo in modo che non sia necessario fornirle manualmente:

fmt::print("{}", a);

È stato testato con i principali compilatori e fornisce un output coerente su tutte le piattaforme.

Disclaimer : sono l'autore di questa libreria.

Il tipo effettivo sottostante size_t dipende dall'implementazione . Lo standard C lo definisce come il tipo restituito dall'operatore sizeof; oltre ad essere senza segno e una sorta di tipo integrale, size_t può essere praticamente qualsiasi cosa la cui dimensione possa contenere il valore più grande che ci si aspetta venga restituito da sizeof ().

Di conseguenza, la stringa di formato da utilizzare per size_t può variare a seconda del server. Dovrebbe sempre avere la "u", ma potrebbe essere l o d o forse qualcos'altro ...

Un trucco potrebbe essere quello di eseguire il cast sul tipo integrale più grande sulla macchina, assicurando che non vi siano perdite nella conversione, e quindi utilizzare la stringa di formato associata a questo tipo noto.

#include <cstdio>
#include <string>
#include <type_traits>

namespace my{
    template<typename ty>
    auto get_string(ty&& arg){
        using rty=typename::std::decay_t<::std::add_const_t<ty>>;
        if constexpr(::std::is_same_v<char, rty>)
            return ::std::string{1,arg};
        else if constexpr(::std::is_same_v<bool, rty>)
            return ::std::string(arg?"true":"false");
        else if constexpr(::std::is_same_v<char const*, rty>)
            return ::std::string{arg};
        else if constexpr(::std::is_same_v<::std::string, rty>)
            return ::std::forward<ty&&>(arg);
        else
            return ::std::to_string(arg);
    };

    template<typename T1, typename ... Args>
    auto printf(T1&& a1, Args&&...arg){
        auto str{(get_string(a1)+ ... + get_string(arg))};
        return ::std::printf(str.c_str());
    };
};

Più avanti nel codice:

my::printf("test ", 1, '\t', 2.0);