What is the memory footprint of a Nullable<T>

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?


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...

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.

            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...

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)

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.

32-bit and 64-bit machines:

  • int == 4 bytes
  • int? == 8 bytes == 4 for int + 4 for the nullable type wrapper.

The nullable type wrapper requires 4 bytes of storage. And the integer itself requires 4 bytes for each element. This is an efficient implementation. In an array many nullable types are stored in contiguous memory.

Based on a personal test (.NET Framework 4.6.1, x64, Release) and from – https://www.dotnetperls.com/nullable-memory

Also, if interesting: why int on x64 equals only 4 bytes?

Note: this is valid for Nullable<int> only, the size of Nullable<T> totally depends on the type.

You can check using some code similar to the one at https://www.dotnetperls.com/nullable-memory.

I got the following results:

  • Int32 4 bytes
  • Int32? 8 bytes
  • Int16 2 bytes
  • Int16? 4 bytes
  • Int64 8 bytes
  • Int64? 16 bytes
  • Byte 1 bytes
  • Byte? 2 bytes
  • bool 1 bytes
  • bool? 2 bytes

Need Your Help

module.exports client side

javascript node.js browser module requirejs

I've created a node module that is essentially just some useful JS that can also be used client side. I know that require.js can load common.js components, but I don't necessarily want to make a ma...