什么时候使用size_t作为模板函数的参数是个坏主意？

Question

When is it a bad idea to use size_t as a parameter for a template function? I know that size_t is an unsigned int, but my professor mentioned in class that using size_t as a parameter for a template class is bad. Any ideas why?

Answer 1

There's nothing wrong with using size_t as a template parameter.

There's nothing wrong with using any type as a template parameter.

Answer 2

The only reason I can think of is that size_t is different sizes in 32 and 64 bit. If you were using it in some sort of serialization template function, your data serialized in 32 bit code would be incompatible with your 64 bit code. That's more of an issue with serializing size_t and not really specific to templates. If you ask your prof, I'd be interested in hearing what he says!

Answer 3

Interpret this as you will, but TCC and GCC will not quietly accept size_t or unsigned int when coding for ReadFile() and many other functions in the Win32 API. It MUST be a DWORD if directed to be so. No exceptions. The API refs make that point very explicit, and coding otherwise soon tells you that they mean it. Do any different, and you're left with all kinds of ugly casting to be done too.

What I find odd is that I'd accepted advocacy of size_t from people who I thought know better than I do. (Most do, amongst coders in general!) They advocated it for 'portability' reasons. It is odd that they failed to consider compatibility with the Win32 API when deciding what is 'portable'.

My own view, in hindsight, is not to allow such people to lecture you on types. As the very short answer by 'QuestionC' given above indicates, ANY type MAY be valid. Surely the point is to DEFINE, meaning, we should know what we choose, and why. There are usually far greater reasons to determine the appropriate method for code matched to some host, such as purpose for the program. No type, no compiler, can be adequately prepared to make these decisions. That's our job. Context is everything, and it is foolish to think that ultimate compatibility or portability is possible merely by choosing a variable type according to advice from a person who has no idea what we're doing with it. The more the web breaks ever more browsers and sites, the more self-evidently true that is.

Inventing yet another 'type' for 'portability' reasons makes as much sense, ultimately, as ordering 'one ring to bind them'.