Código limpio para printf size_t en C ++ (o: equivalente más cercano de% z de C99 en C ++)

Tengo un código C ++ que imprime un size_t:

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

Me gustaría que esto se compilara sin advertencias en arquitecturas de 32 y 64 bits.

Si esto fuera C99, podría usar printf("%z", a);. Pero AFAICT %zno existe en ningún dialecto estándar de C ++. Entonces, en cambio, tengo que hacer

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

que es realmente feo.

Si no hay ninguna facilidad para imprimir size_tmensajes de correo electrónico integrados en el lenguaje, me pregunto si es posible escribir un contenedor printf o algo así que inserte las conversiones apropiadas en size_tlos mensajes de correo electrónico para eliminar las advertencias falsas del compilador mientras se mantienen las buenas.

¿Algunas ideas?

La mayoría de los compiladores tienen su propio especificador size_ty ptrdiff_targumentos, Visual C ++, por ejemplo, usa% Iu y% Id respectivamente, creo que gcc le permitirá usar% zu y% zd.

Podrías crear 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

Uso:

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

El printfespecificador de formato %zufuncionará bien en sistemas C ++; no hay necesidad de hacerlo más complicado.

C ++ 11

C ++ 11 importa C99, por lo que std::printfdebería admitir el %zuespecificador de formato C99 .

C ++ 98

En la mayoría de las plataformas, size_ty uintptr_tson equivalentes, en cuyo caso puede utilizar la PRIuPTRmacro definida en <cinttypes>:

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

Si realmente quieres estar seguro, envía uintmax_ty usa PRIuMAX:

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

En windows y la implementación de printf de Visual Studio

 %Iu

funciona para mi. ver msdn

Ya que está usando C ++, ¿por qué no usar IOStreams? Eso debería compilarse sin advertencias y hacer lo correcto con reconocimiento de tipos, siempre que no esté utilizando una implementación de C ++ con muerte cerebral que no defina un operator <<for size_t.

Cuando la salida real se tiene que hacer con printf(), todavía se puede combinar con iostreams para conseguir un comportamiento de tipo seguro:

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

No es súper eficiente, pero su caso anterior trata con E / S de archivos, por lo que ese es su cuello de botella, no este código de formato de cadena.

aquí hay una posible solución, pero no es muy 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 ) );

La biblioteca fmt proporciona una implementación portátil rápida (y segura) deprintf incluir el zmodificador para size_t:

#include "fmt/printf.h"

size_t a = 42;

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

Además de eso, es compatible con la sintaxis de cadenas de formato similar a Python y captura información de tipo para que no tenga que proporcionarla manualmente:

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

Ha sido probado con los principales compiladores y proporciona resultados consistentes en todas las plataformas.

Descargo de responsabilidad : soy el autor de esta biblioteca.

El tipo efectivo subyacente a size_t depende de la implementación . C Standard lo define como el tipo devuelto por el operador sizeof; aparte de no estar firmado y ser una especie de tipo integral, size_t puede ser prácticamente cualquier tamaño cuyo tamaño pueda acomodar el valor más grande que se espera que devuelva sizeof ().

En consecuencia, la cadena de formato que se utilizará para size_t puede variar según el servidor. Siempre debe tener la "u", pero puede ser l o d o tal vez algo más ...

Un truco podría ser convertirlo en el tipo integral más grande en la máquina, asegurando que no se pierdan en la conversión y luego usar la cadena de formato asociada con este tipo conocido.

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

Más adelante en el código:

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