Làm sạch mã thành printf size_t trong C ++ (hoặc: Tương đương gần nhất với% z của C99 trong C ++)

Tôi có một số mã C ++ in ra size_t:

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

Tôi muốn điều này được biên dịch mà không có cảnh báo trên cả kiến ​​trúc 32-bit và 64-bit.

Nếu đây là C99, tôi có thể sử dụng printf("%z", a);. Nhưng AFAICT %zkhông tồn tại trong bất kỳ phương ngữ C ++ chuẩn nào. Vì vậy, thay vào đó, tôi phải làm

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

mà thực sự là xấu xí.

Nếu không có tiện ích nào để in size_tđược tích hợp sẵn trong ngôn ngữ, tôi tự hỏi liệu có thể viết một trình bao bọc printf hoặc somes như vậy sẽ chèn các phôi thích hợp vào size_tđể loại bỏ các cảnh báo trình biên dịch giả trong khi vẫn duy trì các phôi tốt hay không.

Bất kỳ ý tưởng?

Hầu hết các trình biên dịch đều có bộ chỉ định riêng cho size_tvàptrdiff_t đối số , ví dụ Visual C ++ sử dụng% Iu và% Id tương ứng, tôi nghĩ rằng gcc sẽ cho phép bạn sử dụng% zu và% zd.

Bạn có thể tạo một 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

Sử dụng:

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

Bộ printfđịnh dạng %zusẽ hoạt động tốt trên các hệ thống C ++; không cần phải làm cho nó phức tạp hơn.

C ++ 11

C ++ 11 nhập C99 std::printfnên hỗ trợ %zuđịnh dạng C99 .

C ++ 98

Trên hầu hết các nền tảng size_tvà uintptr_ttương đương, trong trường hợp đó bạn có thể sử dụng PRIuPTRmacro được xác định trong <cinttypes>:

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

Nếu bạn thực sự muốn an toàn, hãy truyền đến uintmax_tvà sử dụngPRIuMAX :

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

Trên windows và triển khai Visual Studio của printf

 %Iu

làm việc cho tôi. xem msdn

Vì bạn đang sử dụng C ++, tại sao không sử dụng IOStreams? Điều đó sẽ biên dịch mà không có cảnh báo và thực hiện đúng loại nhận biết, miễn là bạn không sử dụng triển khai C ++ chết não không định nghĩa operator <<for size_t.

Khi đầu ra thực tế phải được thực hiện với printf(), bạn vẫn có thể kết hợp nó với IOStreams để có được hành vi an toàn kiểu:

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

Nó không phải là siêu hiệu quả, nhưng trường hợp của bạn ở trên liên quan đến I / O tệp, vì vậy đó là nút cổ chai của bạn, không phải mã định dạng chuỗi này.

đây là một giải pháp khả thi, nhưng nó không hoàn toàn là một giải pháp tốt ..

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

Các thư viện fmt cung cấp một xách tay (và an toàn) nhanh chóng thực hiện printfbao gồm các zsửa đổi đối với size_t:

#include "fmt/printf.h"

size_t a = 42;

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

Ngoài ra, nó hỗ trợ cú pháp chuỗi định dạng giống Python và nắm bắt thông tin loại để bạn không phải cung cấp nó theo cách thủ công:

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

Nó đã được thử nghiệm với các trình biên dịch lớn và cung cấp đầu ra nhất quán trên các nền tảng.

Tuyên bố từ chối trách nhiệm : Tôi là tác giả của thư viện này.

Loại hiệu quả bên dưới size_t phụ thuộc vào việc triển khai . C Standard định nghĩa nó là kiểu được trả về bởi toán tử sizeof; ngoài việc không được đánh dấu và là một loại tích phân, size_t có thể là bất cứ thứ gì mà kích thước có thể chứa giá trị lớn nhất mà sizeof () mong đợi được trả về.

Do đó, chuỗi định dạng được sử dụng cho size_t có thể khác nhau tùy thuộc vào máy chủ. Nó phải luôn có chữ "u", nhưng có thể là l hoặc d hoặc có thể là một cái gì đó khác ...

Một thủ thuật có thể là chuyển nó thành kiểu tích phân lớn nhất trên máy, đảm bảo không bị mất trong quá trình chuyển đổi và sau đó sử dụng chuỗi định dạng được liên kết với kiểu đã biết này.

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

Sau đó trong mã:

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