Bersihkan kode ke printf size_t di C ++ (atau: Setara terdekat dengan% z C99 di C ++)

Saya memiliki beberapa kode C ++ yang mencetak size_t:

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

Saya ingin ini mengompilasi tanpa peringatan pada arsitektur 32 dan 64-bit.

Jika ini C99, saya bisa menggunakan printf("%z", a);. Tetapi AFAICT %ztidak ada dalam dialek C ++ standar. Jadi, saya harus melakukannya

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

yang sangat jelek.

Jika tidak ada fasilitas untuk mencetak yang ada size_tdi dalam bahasa, saya bertanya-tanya apakah mungkin untuk menulis pembungkus printf atau semacamnya yang akan memasukkan cetakan yang sesuai size_tuntuk menghilangkan peringatan compiler palsu sambil tetap mempertahankan yang baik.

Ada ide?

Kebanyakan kompiler memiliki specifier size_tdan ptrdiff_targumennya sendiri, Visual C ++ misalnya menggunakan% Iu dan% Id masing-masing, saya pikir gcc akan memungkinkan Anda untuk menggunakan% zu dan% zd.

Anda bisa membuat 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

Pemakaian:

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

Penentu printfformat %zuakan bekerja dengan baik pada sistem C ++; tidak perlu membuatnya lebih rumit.

C ++ 11

C ++ 11 mengimpor C99 sehingga std::printfharus mendukung penentu %zuformat C99 .

C ++ 98

Pada sebagian besar platform, size_tdan uintptr_tsetara, dalam hal ini Anda dapat menggunakan PRIuPTRmakro yang ditentukan di <cinttypes>:

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

Jika Anda benar - benar ingin aman, transmisikan ke uintmax_tdan gunakan PRIuMAX:

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

Pada Windows dan implementasi Visual Studio printf

 %Iu

bekerja untuk saya. lihat msdn

Karena Anda menggunakan C ++, mengapa tidak menggunakan IOStreams? Itu harus dikompilasi tanpa peringatan dan melakukan hal yang benar-benar sadar jenis, selama Anda tidak menggunakan implementasi C ++ yang tidak mendefinisikan operator <<untuk size_t.

Ketika keluaran sebenarnya harus diselesaikan printf(), Anda masih dapat menggabungkannya dengan IOStreams untuk mendapatkan perilaku tipe-aman:

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

Ini tidak super efisien, tetapi kasus Anda di atas berkaitan dengan file I / O, jadi itu hambatan Anda, bukan kode pemformatan string ini.

inilah solusi yang mungkin, tetapi tidak cukup bagus ..

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

The perpustakaan fmt menyediakan portabel (dan aman) pelaksanaan cepat printftermasuk zpengubah untuk size_t:

#include "fmt/printf.h"

size_t a = 42;

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

Selain itu, ia mendukung sintaks string format seperti Python dan menangkap informasi tipe sehingga Anda tidak perlu menyediakannya secara manual:

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

Ini telah diuji dengan kompiler utama dan memberikan output yang konsisten di seluruh platform.

Penafian : Saya adalah pembuat perpustakaan ini.

Jenis efektif yang mendasari size_t bergantung pada implementasi . C Standar mendefinisikannya sebagai tipe yang dikembalikan oleh ukuran operator; Selain unsigned dan semacam tipe integral, size_t bisa menjadi apa saja yang ukurannya bisa menampung nilai terbesar yang diharapkan akan dikembalikan oleh sizeof ().

Akibatnya format string yang akan digunakan untuk size_t dapat bervariasi tergantung pada server. Itu harus selalu memiliki "u", tapi mungkin l atau d atau mungkin sesuatu yang lain ...

Triknya bisa dengan melemparkannya ke tipe integral terbesar di mesin, memastikan tidak ada kerugian dalam konversi, dan kemudian menggunakan string format yang terkait dengan tipe yang diketahui ini.

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

Nanti di kode:

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