Is Returning a Stack-Allocated Pointer in Go Safe?

Returning a Pointer on Stack in Go: Unveiled

In C programming, returning a pointer to a stack-allocated variable can lead to issues, as the memory is discarded after the function returns. However, in Go, returning pointers to stack-created variables is not only safe but also a common practice.

Utilizing escape analysis, Go automatically allocates values that escape the stack (pointers that may be referenced outside the current scope) to the heap. This eliminates the need to be concerned about the allocation location of variables.

As stated in the Go FAQ: "How do I know whether a variable is allocated on the heap or the stack?":

if the compiler cannot prove that the variable is not referenced after the function returns, then the compiler must allocate the variable on the garbage-collected heap to avoid dangling pointer errors

To observe the compiler's optimization choices, use the -gcflags -m option during compilation. This will provide insights into how Go manages memory allocation for different scenarios.

Example:

Consider the following Go code:

package main

import (
    "fmt"
)

func main() {
    fmt.Println(*(something()))
}

func something() *string {
    s := "a"
    return &s
}

In this example, the function something returns a pointer to a stack-allocated variable. However, due to Go's escape analysis, the compiler recognizes that the returned pointer is used outside the function's scope and allocates the variable on the heap. This ensures that the pointers remain valid and dereferenceable.

The above is the detailed content of Is Returning a Stack-Allocated Pointer in Go Safe?. For more information, please follow other related articles on the PHP Chinese website!