What is the memory footprint of a Nullable<T>

Question

An int (Int32) has a memory footprint of 4 bytes. But what is the memory footprint of:

int? i = null;

and :

int? i = 3;

Is this in general or type dependent?

Answer 1

An int? is a struct containing a boolean hasValue, and an int. Therefore, it has a footprint of 5 bytes. The same applies to all instances of a nullable<T>: size = sizeof(T)+sizeof(bool)

Answer 2

I'm not 100% sure, but I believe it should be 8 Bytes, 4 bytes for the int32, and (since every thing has to be 4-Byte aligned on a 32 bit machine) 4 bytes for a boolean indicating whether the integer value has been specified or not.

On a 64 Bit machine it would still be 8 bytes (64 bits) since that is the smallest chunk of memory that can be addressed...

Answer 3

The nullable type is a structure that contains the regular variable and a flag for the null state.

For a nullable int that would mean that it contains five bytes of data, but it's of course padded up to complete words, so it's using eight bytes.

You can generally expect that any nullable type will be four bytes larger than the regular type, except for small types like byte and boolean.

Answer 4

The size of Nullable<T> is definitely type dependent. The structure has two members

• boolean: For the hasValue
• value: for the underlying value

The size of the structure will typically map out to 4 plus the size of the type parameter T.

Answer 5

            int? a = 3;
  00000038  lea         ecx,[ebp-48h] 
  0000003b  mov         edx,3 
  00000040  call        78BFD740 
  00000045  nop              
            a = null;
  00000046  lea         edi,[ebp-48h] 
  00000049  pxor        xmm0,xmm0 
  0000004d  movq        mmword ptr [edi],xmm0 

It seems that first dword is for the value, and the second one is for null flag. So, 8 bytes total.

Curious, BinaryWritter doesn't like to write nullable types. I was wandering if it could pack it tighter then 8 bytes...