Limpe o código para printf size_t em C ++ (ou: equivalente mais próximo de% z de C99 em C ++)

Eu tenho algum código C ++ que imprime um size_t:

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

Eu gostaria que isso fosse compilado sem avisos nas arquiteturas de 32 e 64 bits.

Se fosse C99, eu poderia usar printf("%z", a);. Mas AFAICT %znão existe em nenhum dialeto C ++ padrão. Então, em vez disso, eu tenho que fazer

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

o que é realmente feio.

Se não houver nenhum recurso para imprimir size_ts embutidos na linguagem, eu me pergunto se é possível escrever um wrapper printf ou algum tal que insira os casts apropriados nos size_ts de modo a eliminar avisos do compilador espúrios enquanto mantém os bons.

Alguma ideia?

A maioria dos compiladores tem seu próprio especificador para size_te ptrdiff_targumentos, Visual C ++, por exemplo, usa% Iu e% Id respectivamente. Acho que o gcc permitirá que você use% zu e% zd.

Você pode criar uma 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

Uso:

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

O printfespecificador de formato %zufuncionará bem em sistemas C ++; não há necessidade de torná-lo mais complicado.

C ++ 11

C ++ 11 importa C99, portanto, std::printfdeve oferecer suporte ao %zuespecificador de formato C99 .

C ++ 98

Na maioria das plataformas, size_te uintptr_tsão equivalentes, caso em que você pode usar a PRIuPTRmacro definida em <cinttypes>:

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

Se você realmente deseja estar seguro, transmita uintmax_te use PRIuMAX:

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

No Windows e na implementação do Visual Studio de printf

 %Iu

funciona para mim. ver msdn

Já que você está usando C ++, por que não usar IOStreams? Isso deve compilar sem avisos e fazer a coisa certa ciente do tipo, contanto que você não esteja usando uma implementação C ++ com morte cerebral que não defina um operator <<para size_t.

Quando a saída real tiver que ser feita printf(), você ainda pode combiná-la com IOStreams para obter um comportamento de tipo seguro:

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

Não é supereficiente, mas seu caso acima lida com E / S de arquivo, então esse é o seu gargalo, não este código de formatação de string.

aqui está uma solução possível, mas não é muito bonita ..

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

A biblioteca fmt fornece uma implementação portátil rápida (e segura) deprintf incluir o zmodificador para size_t:

#include "fmt/printf.h"

size_t a = 42;

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

Além disso, ele oferece suporte à sintaxe de string de formato semelhante ao Python e captura informações de tipo para que você não precise fornecê-las manualmente:

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

Ele foi testado com os principais compiladores e fornece saída consistente em todas as plataformas.

Isenção de responsabilidade : sou o autor desta biblioteca.

O tipo efetivo subjacente size_t é dependente da implementação . C Standard o define como o tipo retornado pelo operador sizeof; além de não ter sinal e ser uma espécie de tipo integral, o size_t pode ser praticamente qualquer coisa cujo tamanho pode acomodar o maior valor esperado para ser retornado por sizeof ().

Conseqüentemente, a string de formato a ser usada para size_t pode variar dependendo do servidor. Deve sempre ter o "u", mas pode ser l ou d ou talvez outra coisa ...

Um truque poderia ser convertê-lo no maior tipo integral da máquina, garantindo que não houvesse perda na conversão e, em seguida, usar a string de formato associada a esse tipo conhecido.

#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());
    };
};

Posteriormente no código:

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