What are the usage differences between size_t and off_t?
c++, linux
Solution
`size_t` is for objects, `off_t` is for files.
`mmap` merges the two concepts, pretty much by definition. Personally I think I'd use `size_t`, since no matter what else it is, a mapped file is also an array in (virtual) memory.
`size_t` is standard C++, `off_t` is Posix, and `off64_t` is a GNU extension that goes with the functions `fopen64`, `ftello64`, etc. I think it should always be the same type as `off_t` on 64 bit GNU systems, but don't bet your company on that without checking.
Should it be relevant, `off_t` is signed whereas `size_t` is unsigned. But the signed counterpart to `size_t` is `ptrdiff_t`, so when you need a signed type it doesn't automatically mean you should use `off_t` or `off64_t`.
Problem
Other than the size of the values that each type can hold, what are the main differences in usage between `size_t` and `off_t`? Is it just a convention that `size_t` types are used for absolute sizes and `off_t` types are used for offsets? Or does it go deeper than that? I am writing a wrapper class to enable the writing of large files using `mmap` and I want to know what the best types are to use for their arguments. Given that I want to write to files > 4GB, I'm tempted to use size_t for everything, but is that the best practice? (or should I be using some `off64_t` types for certain functions?) For example, should my `writeAt` function be declared as: ``` MMapWriter::writeAt(off64_t offset, const void* src, size_t size) ``` or ``` MMapWriter::writeAt(size_t offset, const void* src, size_t size) ```