Go Memory Allocation: `new()` vs `&{}` – What's the Real Difference?

Allocation Conundrum: new() vs "Regular" Pointers in Go

In the realm of Go programming, a question arises: is there a significant difference between the following two code segments when allocating memory for a new object?

Code Segment 1:

v := &Vector{}

Code Segment 2:

v := new(Vector)

Answer:

Surprisingly, there is no noticeable difference between the two code segments. They both achieve the same result: creating a pointer to a new instance of the Vector type.

Detailed Explanation:

When calling new(Vector), the new keyword allocates memory for a new Vector object and returns a pointer to that object. Similarly, &Vector{} also allocates memory for a new Vector object and returns a pointer to it.

To illustrate, consider the following code:

package main

import "fmt"
import "reflect"

type Vector struct {
    x   int
    y   int
}

func main() {
    v := &Vector{}
    x := new(Vector)
    fmt.Println(reflect.TypeOf(v))
    fmt.Println(reflect.TypeOf(x))
}

Output:

*main.Vector
*main.Vector

As you can see, both v and x are pointers to Vector objects. They have the same type.

Use Cases:

While both code segments achieve the same result, some developers argue that new is more appropriate when the allocated memory will be immediately dereferenced and used, as it helps avoid double-dereferencing errors. For example:

// Allocates memory and immediately dereferences it
v := new(Vector).x

Conclusion:

In conclusion, the choice between using new and the "regular" allocation syntax in Go purely comes down to personal preference. Both methods allocate memory and return a pointer to the newly created object, offering identical functionality.

The above is the detailed content of Go Memory Allocation: `new()` vs `&{}` – What's the Real Difference?. For more information, please follow other related articles on the PHP Chinese website!