Memory Management of Returned Pointers: A Safe Practice in Go

In C, returning a pointer to a stack-allocated variable can lead to undefined behavior due to the deletion of memory upon function return. This raises the question of whether similar behavior occurs in Go and whether it's safe to return such pointers.

In Go, the behavior is surprisingly different. The compiler does not generate any errors for returning stack-allocated pointers like the following example:

package main

import (
    "fmt"
)

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

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

Unlike C, this code in Go is perfectly valid and will not produce any runtime errors. This is because Go employs a sophisticated technique known as escape analysis.

Escape analysis is a compiler optimization that determines whether a value or pointer escapes its function scope. If the value or pointer is found to escape, the compiler places it on the garbage-collected heap instead of on the stack. In this case, the returned pointer *s escapes the scope of the something() function and is therefore placed on the heap.

The Go FAQ succinctly explains the rule regarding memory allocation: if the compiler cannot prove that a variable is no longer referenced after the function returns, it allocates the variable on the heap to prevent dangling pointer errors. This strategy eliminates the need for manual memory management and ensures that pointed data remains accessible after function return.

To observe the compiler's escape analysis optimizations during compilation, use the -gcflags -m option. This option will provide insight into the decisions made regarding heap and stack allocation.