Where does size_t come from when I don't have anything included in an empty project?
If you don't have anything included, then you can't use size_t
. It's defined in <stddef.h>
(and perhaps also in <cstddef>
, if your version of that header puts the definitions in the global namespace as well as std
).
Is it reasonable to always assume size_t == std::size_t?
Yes. All types and functions defined by the C library are included in the std
namespace, as long as you include the appropriate C++ header (e.g. <cstddef>
rather than <stddef.h>
)
When should I use std::_::size_type?
Do you mean the size_type
types defined in some standard classes and templates such as vector
? You could use those when using those classes if you like. In most cases, you'll know that it's the same as size_t
, so you might as well use that and save a bit of typing. If you're writing generic code, where you don't know what the class is, then it's better to use size_type
in case it's not compatible with size_t
.
For example, you might want to write a container designed to hold more items than can be represented by size_t
. You might use some kind of big number type to represent the container's size, which isn't convertible to size_t
. In that case, code like size_t s = c.size()
would fail to compile - you'd need to use Container::size_type
instead.
Best Answer
A short holds numbers too. As does a signed char.
But none of those types are guaranteed to be large enough to represent the sizes of any strings.
string::size_type
guarantees just that. It is a type that is big enough to represent the size of a string, no matter how big that string is.For a simple example of why this is necessary, consider 64-bit platforms. An int is typically still 32 bit on those, but you have far more than 2^32 bytes of memory.
So if a (signed) int was used, you'd be unable to create strings larger than 2^31 characters. size_type will be a 64-bit value on those platforms however, so it can represent larger strings without a problem.