Bereinigen Sie den Code für printf size_t in C ++ (oder: Das nächste Äquivalent von% z von C99 in C ++)

Ich habe einen C ++ - Code, der Folgendes druckt size_t:

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

Ich möchte, dass dies ohne Warnungen auf 32- und 64-Bit-Architekturen kompiliert wird.

Wenn dies C99 wäre, könnte ich verwenden printf("%z", a);. AFAICT %zexistiert jedoch in keinem Standard-C ++ - Dialekt. Also muss ich stattdessen tun

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

Das ist wirklich hässlich.

Wenn es keine Möglichkeit gibt, size_ts in die Sprache zu drucken , frage ich mich, ob es möglich ist, einen printf-Wrapper oder einen solchen zu schreiben, der die entsprechenden Casts auf size_ts einfügt , um falsche Compiler-Warnungen zu beseitigen und gleichzeitig die guten beizubehalten.

Irgendwelche Ideen?

Die meisten Compiler haben einen eigenen Bezeichner für size_tund ptrdiff_tArgumente. Visual C ++ verwendet beispielsweise% Iu bzw.% Id. Ich denke, dass Sie mit gcc% zu und% zd verwenden können.

Sie könnten ein Makro erstellen:

#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

Verwendung:

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

Der printfFormatbezeichner %zufunktioniert auf C ++ - Systemen einwandfrei. Es besteht keine Notwendigkeit, es komplizierter zu machen.

C ++ 11

C ++ 11 importiert C99 und std::printfsollte daher den C99- %zuFormatbezeichner unterstützen.

C ++ 98

Auf den meisten Plattformen size_tund uintptr_tgleichwertig sind, in diesem Fall können Sie die verwenden können , PRIuPTRMakro definiert in <cinttypes>:

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

Wenn Sie wirklich sicher sein wollen, werfen Sie auf uintmax_tund verwenden Sie PRIuMAX:

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

Unter Windows und der Visual Studio-Implementierung von printf

 %Iu

funktioniert bei mir. siehe msdn

Warum nicht IOStreams verwenden, da Sie C ++ verwenden? Das sollte ohne Warnungen kompiliert werden und die richtige typbewusste Aktion ausführen, solange Sie keine hirntote C ++ - Implementierung verwenden, die kein operator <<for definiertsize_t .

Wenn die eigentliche Ausgabe erledigt werden muss printf(), können Sie sie dennoch mit IOStreams kombinieren, um ein typsicheres Verhalten zu erzielen:

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

Es ist nicht sehr effizient, aber Ihr obiger Fall befasst sich mit Datei-E / A. Das ist also Ihr Engpass, nicht dieser Code zur Formatierung von Zeichenfolgen.

Hier ist eine mögliche Lösung, aber es ist keine schöne.

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

Die fmt - Bibliothek bietet eine schnelle portable (und sicher) Umsetzung printfeinschließlich der zModifikator für size_t:

#include "fmt/printf.h"

size_t a = 42;

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

Darüber hinaus unterstützt es die Python-ähnliche Format-String-Syntax und erfasst Typinformationen, sodass Sie diese nicht manuell bereitstellen müssen:

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

Es wurde mit großen Compilern getestet und bietet plattformübergreifende konsistente Ausgabe.

Haftungsausschluss : Ich bin der Autor dieser Bibliothek.

Der effektive Typ, der size_t zugrunde liegt, ist implementierungsabhängig . C Standard definiert es als den Typ, der vom Operator sizeof zurückgegeben wird. Abgesehen davon, dass es nicht signiert ist und eine Art integraler Typ ist, kann size_t so ziemlich alles sein, welche Größe den größten Wert aufnehmen kann, der von sizeof () erwartet wird.

Folglich kann die für eine size_t zu verwendende Formatzeichenfolge je nach Server variieren. Es sollte immer das "u" haben, kann aber l oder d oder vielleicht etwas anderes sein ...

Ein Trick könnte darin bestehen, ihn in den größten integralen Typ auf dem Computer umzuwandeln, um sicherzustellen, dass bei der Konvertierung kein Verlust auftritt, und dann die diesem bekannten Typ zugeordnete Formatzeichenfolge zu verwenden.

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

Später im Code:

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