使用size_t指定C的printf中字符串的精度

Question

I have a structure to represent strings in memory looking like this:

typedef struct {
    size_t l;
    char   *s;
} str_t;

I believe using size_t makes sense for specifying the length of a char string. I'd also like to print this string using printf("%.*s\\n", str.l, str.s) . However, the * precision expects an int argument, not size_t . I haven't been able to find anything relevant about this. Is there someway to use this structure correctly, without a cast to int in the printf() call?

Answer 1

printf("%.*s\n", (int)str.l, str.s)
//               ^^^^^ use a type cast

Edit

OK, I didn't read the question properly. You don't want to use a type cast, but I think, in this case: tough.

Either that or simply use fwrite

fwrite(str.s, str.l, 1, stdout);
printf("\n");

Answer 2

You could do a macro

#define STR2(STR) (int const){ (STR).l }, (char const*const){ (STR).s }

and then use this as printf("%.*s\\n", STR2(str)) .

Beware that this evaluates STR twice, so be carefull with side effects, but you probably knew that already.

Edit:

I am using compound initializers such that these are implicit conversions. If things go wrong there are more chances that the compiler will warn you than with an explicit cast.

Eg if STR has a field .l that is a pointer and you'd only put a cast to int , all compilers would happily convert that pointer to int . Similar for the .s field this really has to correspond to a char* or something compatible, otherwise you'd see a warning or error.

Answer 3

There is no guarantee that the size_t is an int, or that it can be represented within an int. It's just part of C's legacy in not defining the exact size of an int, coupled with concerns that size_t's implementation might need to be leveraged to address large memory areas (ones that have more than MAX_INT values in them).

The most common error concerning size_t is to assume that it is equivalent to unsigned int. Such old bugs were common, and from personal experience it makes porting from a 32 bit to a 64 bit architecture a pain, as you need to undo this assumption.

At best, you can use a cast. If you really want to get rid of the cast, you could alternatively discard the use of size_t.