Details you need to pay attention to when the return value of a Golang function is a pointer

Golang language is very flexible in the design of function return values. In addition to basic data types, return values ​​can also be pointers, arrays, slices, structures, etc. Especially when the return value of a function is a pointer type, more details need to be paid attention to. This article will explain this issue in detail.

1. Do not return the address of local variables

In the Golang language, when a function returns a pointer type, be careful not to return the address of local variables. Because the life cycle of local variables is only within the function, when the function ends, the memory space occupied by these variables will be recycled. At this time, the returned pointer points to an invalid memory address, and using it again will cause problems that are very difficult to trace. . Therefore, it is recommended to use new or make operations inside the function to allocate a new memory space and then return it. For example:

func foo() *int {
    var x int = 0
    return &x  // 错误的返回局部变量地址
}

func bar() *int {
    var x int = 0
    return new(int)   // 返回新分配的内存地址
}

2. Do not return multiple pointers to the same variable

In some cases, it may be necessary to return multiple pointer type values ​​at once, but it is necessary Note that these pointers cannot point to the same variable. Because doing so will cause the values ​​pointed by other pointers to change when one pointer is used. For example:

func foo() (*int, *int) {
    var x int = 1
    return &x, &x  // 错误的返回了指向同一个变量的两个指针
}

func main() {
    p1, p2 := foo()
    fmt.Println(*p1, *p2)  // 输出结果为1 1
    *p1 = 2
    fmt.Println(*p1, *p2)  // 输出结果为2 2，p2的值也被改变了
}

Therefore, the correct approach is to return pointers to different variables, or abstract them into a structure type and return them.

3. Do not modify the value pointed by the pointer outside the function

Another issue that needs attention is that modifying the value pointed by the pointer outside the function may cause unexpected problems . Because in the Golang language, pointers can be referenced multiple times, and a pointer can be pointed to by multiple variables. If the value pointed to by a pointer is modified outside the function, all variables pointed to by the pointer will also be changed. For example:

func foo() *int {
    var x int = 1
    p := &x
    return p
}

func main() {
    p := foo()
    q := p
    *p = 2
    fmt.Println(*q)   // 输出结果为2，因为q和p指向同一个变量
}

Therefore, in order to avoid this situation, you need to use the new or make operation inside the function to allocate a new memory space, and then point the pointer to the space, so as to ensure that it will not It affects variables outside the function.

4. Returning a pointer to a null value may cause panic

The last issue to note is that if a null pointer is returned in a function, then when using the A panic exception will be thrown when the pointer is used. Therefore, you must ensure that when using a pointer, the value it points to is not null, otherwise an exception will be triggered. For example:

func foo() *int {
    return nil   // 返回了一个空指针
}

func main() {
    p := foo()
    *p = 1    // 引发panic异常，因为p为空指针
}

Therefore, in order to avoid this situation, you need to make a nil judgment on the pointer before using it.

To sum up, when the return value of a function is a pointer type, there are many details that need to be paid attention to and must be used with great caution, otherwise it will cause various unpredictable problems. Therefore, be sure to check and test carefully when writing code to ensure that this problem does not occur.

The above is the detailed content of Details you need to pay attention to when the return value of a Golang function is a pointer. For more information, please follow other related articles on the PHP Chinese website!