# Practical Go: Impact of Data Structure Position on Size of Struct

📚 3 min read Tweet this post

In programming, the size of data structures can be a critical factor in determining system performance, particularly in systems with limited resources. In Golang, the position of data structures within a struct can have a significant impact on the overall size of the struct. This article will explain why this is the case and provide an example to demonstrate how data structure position affects the size of a struct.

In Golang, a struct is a composite data type that groups together zero or more values with different types. The values are stored in contiguous memory locations, and the size of the struct is determined by the size of its values and any padding bytes added to align the data.

Consider the following code snippet:

``````type example struct {
a byte
b int32
c float64
d byte
}

var mystruct example
``````

In this example, we have defined a struct called `example` that contains four values: a byte, an int32, a float64, and another byte. When we declare an instance of the struct called `mystruct`, the size of the struct will be the sum of the sizes of its values:

``````size := unsafe.Sizeof(mystruct) // Sizeof returns the size in bytes of the type argument
fmt.Println(size) // output: 24
``````

However, the actual size of the struct may be larger than this if padding bytes are added to ensure that the values are aligned on appropriate memory boundaries.

Now consider the following modification to the struct definition:

``````type example struct {
a byte
d byte
b int32
c float64
}

var mystruct example
``````

In this modified version, we have moved the second byte value to appear immediately after the first byte value. When we declare an instance of the struct, the size of the struct will be:

``````size := unsafe.Sizeof(mystruct) // Sizeof returns the size in bytes of the type argument
fmt.Println(size) // output: 24
``````

Even though we have rearranged the order of the values, the size of the struct remains the same. However, this is not always the case. Depending on the types and their positions in the struct, the size of the struct can be affected.

For example, consider the following modification to the struct definition:

``````type example struct {
a byte
c float64
d byte
b int32
}

var mystruct example
``````

In this modified version, we have moved the float64 value to appear immediately after the first byte value, and the second byte value to appear immediately before the int32 value. When we declare an instance of the struct, the size of the struct will be:

``````size := unsafe.Sizeof(mystruct) // Sizeof returns the size in bytes of the type argument
fmt.Println(size) // output: 32
``````

However, if we rearrange the order of the values again to place the float64 value at the end of the struct, the size of the struct will decrease:

``````type example struct {
a byte
d byte
b int32
c float64
}

var mystruct example

size := unsafe.Sizeof(mystruct) // Sizeof returns the size in bytes of the type argument
fmt.Println(size) // output: 24
``````

In this case, the size of the struct is still 24 bytes, but the memory layout of the struct has changed, and the alignment requirements have been satisfied in a different way.

Section titled Conclusion

### Conclusion

The position of data structures within a struct can have a significant impact on the overall size of the struct in Golang. The size of the struct is determined by the sizes of its values and any padding bytes added to align the data. By rearranging the position of the data structures within the struct, the size of the struct can be affected.

It is important to note that while the size of the struct can be affected by the position of its data structures, it is also affected by the underlying architecture of the system. Therefore, it is recommended to use the `unsafe.Sizeof` function to determine the size of the struct and to ensure that the struct is optimized for the underlying system.

Understanding how data structure position affects the size of a struct can help programmers write more efficient and optimized code. By taking into account the memory layout of the struct, programmers can minimize the amount of memory used by their programs, leading to better performance and more efficient use of system resources.

practical go