Czysty kod do printf size_t w C ++ (lub: Najbliższy odpowiednik% z C99 w C ++)

Mam kod w C ++, który wyświetla size_t:

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

Chciałbym, aby kompilacja przebiegła bez ostrzeżeń na architekturach 32- i 64-bitowych.

Gdyby to był C99, mógłbym użyć printf("%z", a);. Ale AFAICT %znie istnieje w żadnym standardowym dialekcie C ++. Więc zamiast tego muszę zrobić

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

co jest naprawdę brzydkie.

Jeśli nie ma możliwości drukowania size_ts wbudowanych w język, zastanawiam się, czy można napisać opakowanie printf lub coś takiego, które wstawi odpowiednie rzutowania na size_ts, aby wyeliminować fałszywe ostrzeżenia kompilatora, jednocześnie zachowując dobre.

Jakieś pomysły?

Większość kompilatorów ma własne specyfikatory size_ti ptrdiff_targumenty, na przykład Visual C ++ używa odpowiednio% Iu i% Id, myślę, że gcc pozwoli ci użyć% zu i% zd.

Możesz stworzyć makro:

#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

Stosowanie:

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

Specyfikator printfformatu %zubędzie działał dobrze w systemach C ++; nie ma potrzeby, aby było to bardziej skomplikowane.

C ++ 11

C ++ 11 importuje C99, więc std::printfpowinien obsługiwać specyfikator %zuformatu C99 .

C ++ 98

Na większości platform size_ti uintptr_tsą równoważne, w takim przypadku możesz użyć PRIuPTRmakra zdefiniowanego w <cinttypes>:

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

Jeśli naprawdę chcesz być bezpieczny, przesyłaj uintmax_ti używaj PRIuMAX:

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

W systemie Windows i implementacji programu Visual Studio printf

 %Iu

pracuje dla mnie. zobacz msdn

Skoro używasz C ++, dlaczego nie skorzystać z IOStreams? Powinno to skompilować się bez ostrzeżeń i działać poprawnie ze świadomością typu, o ile nie używasz martwej dla mózgu implementacji C ++, która nie definiuje operator <<for size_t.

Kiedy trzeba wykonać rzeczywiste dane wyjściowe printf(), nadal można je połączyć z IOStreams, aby uzyskać zachowanie bezpieczne dla typów:

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

Nie jest to super wydajne, ale powyższy przypadek dotyczy operacji we / wy pliku, więc to jest wąskie gardło, a nie ten kod formatujący ciąg.

oto możliwe rozwiązanie, ale nie całkiem ładne ...

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

Biblioteki FMT zapewnia szybki przenośny (i bezpieczne) wdrażanie printftym zmodyfikator dla size_t:

#include "fmt/printf.h"

size_t a = 42;

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

Oprócz tego obsługuje składnię ciągów formatu podobną do Pythona i przechwytuje informacje o typie, dzięki czemu nie musisz podawać ich ręcznie:

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

Został przetestowany z głównymi kompilatorami i zapewnia spójne wyniki na różnych platformach.

Zastrzeżenie : jestem autorem tej biblioteki.

Efektywny typ będący podstawą size_t zależy od implementacji . C Standard definiuje go jako typ zwracany przez operator sizeof; Oprócz tego, że jest bez znaku i jest rodzajem typu całkowitego, size_t może być prawie wszystkim, którego rozmiar może pomieścić największą wartość, której oczekuje się od sizeof ().

W związku z tym ciąg formatu, który ma być używany dla parametru size_t, może się różnić w zależności od serwera. Powinien zawsze mieć „u”, ale może to być l lub d, a może coś innego ...

Sztuczka może polegać na rzutowaniu go na największy typ całkowity na maszynie, zapewniając brak strat w konwersji, a następnie użycie ciągu formatu związanego z tym znanym typem.

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

Później w kodzie:

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