techStud's questions

Estou aprendendo sobre o gerenciamento de memória e coleta de lixo do Go, e encontrei um comportamento inesperado ao tentar desreferenciar um ponteiro depois que a variável para a qual ele aponta sai do escopo.

Em Go, eu entendo que a coleta de lixo (GC) é automática e que ponteiros podem às vezes referenciar memória que não é mais válida. Eu esperava que desreferenciar um ponteiro para uma variável fora do escopo geraria um erro, mas parece que Go não gera um erro ao fazer isso

Aqui está um exemplo mínimo que demonstra o problema:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    var p *int
    {
        x := 42
        p = &x  // p points to x
        fmt.Println(*p) // Prints 42
    }

    // Force garbage collection (for testing)
    runtime.GC()

    // Dereferencing p here should cause an error (since x is out of scope)
    fmt.Println(*p) // This does NOT throw any error
}

O que eu esperava:

• Eu esperava que, após o bloco interno em que x sai do escopo, o ponteiro p fosse um "ponteiro pendente" e imediatamente causasse um erro de tempo de execução quando desreferenciado.
• O erro que eu esperava é algo como: tempo de execução: endereço de memória inválido ou desreferência de ponteiro nulo.

O que realmente acontece:

• O programa não entra em pânico ou gera um erro ao desreferenciar *p mesmo após forçar a coleta de lixo. O valor impresso ainda é o endereço de x, mesmo que x esteja fora do escopo.