Why does strlen() return a 64-bit integer? Am i missing something?

Question

When compiling a 64bit application, why does strlen() return a 64-bit integer? Am i missing somthing?

I understand that strlen() returns a size_t type, and by definition this shouldn’t change, but... Why would strlen need to return a 64-bit integer?

The function is designed to be used with strings. With that said:

Do programmers commonly create multi-gigabyte or multi-terabyte strings? If they did, wouldn’t they need a better way to determine the string length than searching for a NULL character?

I think this is ridiculous, in fact, maybe we need a StrLenAsync() function with a callback just to handle the ultra long process for searching for the NULL in the 40TB string. Sound stupid? Yea, well strlen() returns a 64-bit integer!

Of course, the proposed StrLenAsync() function is a joke.

Answer 1

It looks like, when compiling for a 64-bit target, size_t is defined as 64-bit. This makes sense, since size_t is used for sizes of all kinds of objects, not just strings.

Answer 2

On a 64-bit app, it's definitely possible to create a 5GB string.

The spec is not intended to keep you from doing stupid things.

Even if it wasn't needed, it wouldn't be worth changing the specification of strlen away from using a size_t just to make the return value 4 instead of 8 bytes.

Answer 3

Well, 1) size_t is a typedef and varies with architectures and 2) Wouldn't it make sense to have the largest integer as a return value? Why 32 bits? Why not 16? It's 64 on your machine because that's the max string length possible.

Answer 4

strlen() have to use return type that can represent the size of the largest object in the allocation model.

You could use std::string. Its size_type is equal to the allocator's size_type. So if you will create your own allocator then std::string::size() could use even char as return type.

Thanks to remark in comments. std::string is just a specialization of the std::basic_string. Sure you should use std::basic_string with custom allocator.

Answer 5

Here's a chart which shows the size of some basic types in the most common datamodels:

         ILP32 LP64 LLP64 ILP64
char       8     8     8     8
short     16    16    16    16
int       32    32    32    64
long      32    64    32    64
long long 64    64    64    64
pointer   32    64    64    64
size_t    32    64    64    64

The 32-bit Windows datamodel is ILP32 and the 64-bit Windows datamodel is LLP64.

Answer 6

It's not about whether anybody will actually make a string that size. By convention, ALL return types that indicate the number of bytes something occupies in memory are size_t.

Answer 7

I can think of several applications where a string of 4GB is simply not enough (computational biology, computer forensics are two HUGE ones). Don't assume that because YOU don't do it that nobody else does, either.