在C ++中将代码清除为printf size_t（或：在C ++中与C99的％z最接近）

我有一些C ++代码可以显示size_t：

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

我希望在32位和64位体系结构上进行编译而不会发出警告。

如果这是C99，则可以使用printf("%z", a);。但是AFAICT %z在任何标准C ++方言中都不存在。所以我要做

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

这真的很丑。

如果size_t语言中没有内置的用于打印s的功能，我想知道是否有可能编写一个printf包装器或诸如此类的东西，以便在size_ts 上插入适当的强制转换，从而消除虚假的编译器警告，同时仍保持良好的警告。

有任何想法吗？

大多数编译器都有自己的size_t和ptrdiff_t参数说明符，例如Visual C ++分别使用％Iu和％Id，我认为gcc将允许您使用％zu和％zd。

您可以创建一个宏：

#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

用法：

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

该printf格式说明%zu将工作在C ++系统的罚款; 无需使其更加复杂。

C ++ 11

C ++ 11导入了C99，因此std::printf应支持C99 %zu格式说明符。

C ++ 98

在大多数平台上，size_t并且uintptr_t是等效的，在这种情况下，您可以使用在中PRIuPTR定义的宏<cinttypes>：

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

如果您确实想安全，请强制uintmax_t使用PRIuMAX：

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

在Windows和printf的Visual Studio实现中

 %Iu

为我工作。参见 msdn

由于您使用的是C ++，为什么不使用IOStreams？只要您没有使用没有定义operator <<for 的健忘的C ++实现，那它就应该在没有警告的情况下进行编译并执行正确的类型感知的事情size_t。

当必须使用进行实际输出时printf()，您仍然可以将其与IOStreams结合使用以获得类型安全行为：

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

它不是超级高效，但是上面的案例处理文件I / O，因此这是您的瓶颈，而不是此字符串格式代码。

这是一个可能的解决方案，但这不是一个很好的解决方案。

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

该FMT库提供了快速便携式（安全）实现的printf，包括z了修改size_t：

#include "fmt/printf.h"

size_t a = 42;

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

除此之外，它还支持类似Python的格式字符串语法并捕获类型信息，因此您无需手动提供它：

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

它已经在主要编译器上进行了测试，并提供跨平台的一致输出。

免责声明：我是这个图书馆的作者。

基于size_t的有效类型取决于实现。C标准将其定义为sizeof运算符返回的类型；除了无符号和某种整数类型之外，size_t几乎可以是任何大小可以容纳由sizeof（）返回的最大值的东西。

因此，根据服务器的不同，用于size_t的格式字符串可能会有所不同。它应该始终带有“ u”，但可以是l或d或其他名称。

一个技巧是将其转换为计算机上最大的整数类型，以确保转换不会丢失，然后使用与此已知类型关联的格式字符串。

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

稍后的代码：

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