In Go language, there are two main ways to initialize structure pointers: 1. Use the new() function to initialize zero value; 2. Use the &Struct{} syntax to initialize and assign values. new() is suitable for cases where only zero values are required, while &Struct{} is more flexible and supports specifying field values during initialization. Both create pointers, but the latter is more commonly used and readable. In addition, depending on whether the original data needs to be modified, the appropriate initialization method should be selected to match the method recipient type.

In Go language, it is not difficult to initialize a pointer to a struct, but novices sometimes confuse several writing methods, resulting in the program behavior not as expected. The key is to understand the differences and applicable scenarios between new() and &Struct{} .

Initialize the structure pointer using new()

new() is a built-in function in Go that can be used to allocate memory and return a pointer to that memory. When you create a struct pointer with new() , it initializes each field of the struct to their zero value.

For example:

 type Person struct {
    Name string
    Age int
}

p := new(Person)

In this way, p is a pointer to Person , its field Name is an empty string, and Age is 0.

advantage:

• Simple, suitable for situations where only zero value initialization is required.

shortcoming:

• If you want to customize the initial value of the field, new() is not very convenient.

Initialize and assign values using &Struct{}

A more common and flexible way is to use the &Struct{} syntax directly, which creates a struct instance and returns a pointer to it. You can also assign initial values to fields directly in braces.

for example:

 p := &Person{
    Name: "Alice",
    Age: 30,
}

This way you can specify the value of the field during initialization, and the syntax is clear, suitable for most practical development scenarios.

Notice:

• The field name must be the export field defined in the structure (i.e., the initial letter is capitalized), otherwise the value cannot be assigned outside the package.
• Be careful if only some fields are initialized, the rest will be filled with zero values.

When to use new() and when to use &Struct{} ?

Generally speaking, unless you explicitly only need zero value initialization, it is more recommended to use &Struct{} . Because it is more intuitive, it also supports assignment at initialization, with better readability and flexibility.

You can choose according to the following situations:

• Just need a default zero value? Use new() .
• Want to set the initial value? Use &Struct{} .
• Need partial initialization? Or use &Struct{} , remember to pay attention to the default value of the unassigned field.

Small details: The difference between initialization of structure pointers and values

Sometimes you will see someone writing:

 p1 := Person{}
p2 := &Person{}

The former is the value type of the structure, and the latter is the pointer type. In function argument transfer or method receiver, these two writing methods affect whether the original data is modified.

If the method you wrote is of the *Person type, then use &Person{} to match; if it is of Person type, both are OK (because Go will automatically take references).

Therefore, when initializing the structure pointer, you should use subsequent usage scenarios to determine whether the pointer is needed.

Basically that's it. Initializing structure pointers is not difficult in Go, but it is prone to errors in details, especially the problem of field default values and pointer passing. Paying more attention can avoid many bugs.

The above is the detailed content of How to initialize a pointer to a struct in Go?. For more information, please follow other related articles on the PHP Chinese website!