11

The title is actually a bit misleading, but I wanted to keep it short. I've read about why I should use size_t and I often found statements like this:

size_t is guaranteed to be able to express the maximum size of any object, including any array

I don't really understand what that means. Is there some kind of cap on how much memory you can allocate at once and size_t is guaranteed to be large enough to count every byte in that memory block?

Follow-up question:
What determines how much memory can be allocated?

Community
  • 1
  • 1
Paul Manta
  • 30,618
  • 31
  • 128
  • 208
  • Also have a look at [this answer](http://stackoverflow.com/questions/131803/unsigned-int-vs-size-t/131833#131833) of [this question](http://stackoverflow.com/q/131803/27615) for a great explanation. – razlebe Oct 21 '11 at 13:49

6 Answers6

12

Let's say the biggest object your compiler/platform can have is 4 gb. size_t then is 32 bit. Now let's say you recompile your program on a 64 bit platform able to support objects of size 2^43 - 1. size_t will be at least 43 bit long (but normally it will be 64 bit at this point). The point is that you only have to recompile the program. You don't have to change all your ints to long (if int is 32 bit and long is 64 bit) or from int32_t to int64_t. (if you are asking yourself why 43 bit, let's say that Windows Server 2008 R2 64bit doesn't support objects of size 2^63 nor objects of size 2^62... It supports 8 TB of addressable space... So 43 bit!)

Many programs written for Windows considered a pointer to be as much big as a DWORD (a 32 bit unsigned integer). These programs can't be recompiled on 64 bit without rewriting large swats of code. Had they used DWORD_PTR (an unsigned value guaranteed to be as much big as necessary to contain a pointer) they wouldn't have had this problem.

The size_t "point" is the similar. but different!

size_t isn't guaranteed to be able to contain a pointer!!
(the DWORD_PTR of Microsoft Windows is)

This, in general, is illegal:

void *p = ...
size_t p2 = (size_t)p;

For example, on the old DOS "platform", the maximum size of an object was 64k, so size_t needed to be 16 bit BUT a far pointer needed to be at least 20 bit, because the 8086 had a memory space of 1 mb (in the end a far pointer was 16 + 16 bit, because the memory of an 8086 was segmented)

xanatos
  • 109,618
  • 12
  • 197
  • 280
  • So it's the largest possible integer type on a given platform? – Paul Manta Oct 21 '11 at 13:50
  • 3
    @Paul No. You could still have a 128bit integer. But if `size_t` is 64 bits and `long` is 128 bits (it's legal but I don't think there are compilers with a 128 bits `long`) you still can't `malloc(2^120)` – xanatos Oct 21 '11 at 13:53
  • Thanks. I posted a follow-up question here: http://stackoverflow.com/questions/7850482/what-determines-how-much-memory-can-be-allocated – Paul Manta Oct 21 '11 at 14:03
  • Good thing you mentioned that about size_t not being able to contain pointers: it was going to be my next question. :P – Paul Manta Oct 21 '11 at 14:18
  • 1
    @Paul If your next question is `what type is guaranteed to be able to contain any pointer` be aware that the response is `void*`. `ptrdiff_t` "works" only between elements of the same array, not between absolute addresses. – xanatos Oct 21 '11 at 14:20
  • 3
    @Paul I was forgetting... In C99 you can use `intptr_t` to contain a pointer – xanatos Oct 23 '11 at 19:54
6

Basically it means that size_t, is guaranteed to be large enough to index any array and get the size of any data type.

It is preferred over using just int, because the size of int and other integer types can be smaller than what can be indexed. For example int is usually 32-bits long which is not enough to index large arrays on 64-bit machines. (This is actually a very common problem when porting programs to 64-bit.)

Mysticial
  • 464,885
  • 45
  • 335
  • 332
3

That is exactly the reason. The maximum size of any object in a given programming language is determined by a combination of the OS, the CPU architecture and the compiler/linker in use.

size_t is defined to be big enough to hold the size value of the largest possible object.

This usually means that size_t is typedef'ed to be the same as the largest int type available. So on a 32 bit environment it would typically be 4 bytes and in a 64 bit system 8 bytes.

Tonny
  • 671
  • 5
  • 17
2

size_t is defined for the platform that you are compiling for. Hence it can represent the maximum for that platform.

Ed Heal
  • 59,252
  • 17
  • 87
  • 127
2

size_t is the return of the sizeof operator (see 7.17 c99) therefore it must describe the largest possible object the system can represent.

rerun
  • 25,014
  • 6
  • 48
  • 78
-1

Have a look at

http://en.wikipedia.org/wiki/Size_t

cli_hlt
  • 7,072
  • 2
  • 26
  • 22