Comment la boucle de plage de tranches de Go affecte-t-elle l'attribution d'adresses dans les cartes ?

Comprendre le comportement des plages Go Slice

Dans Go, les tranches sont une structure de données fondamentale qui permet un stockage efficace et dynamique des éléments. Lorsque vous travaillez avec des tranches, il est essentiel de comprendre le comportement des boucles de plage.

Considérez l'extrait de code suivant :

type student struct {
    Name string
    Age  int
}

func main() {
    m := make(map[string]*student)
    s := []student{
        {Name: "Allen", Age: 24},
        {Name: "Tom", Age: 23},
    }

    for _, stu := range s {
        m[stu.Name] = &stu
    }
    fmt.Println(m)
    for key, value := range m {
        fmt.Println(key, value)
    }
}

Le code définit une tranche de structures d'étudiant et une carte. Il parcourt la tranche à l'aide d'une boucle de plage, où chaque élément est affecté à la variable « stu ». Cependant, le comportement inattendu observé est que toutes les entrées de la carte pointent vers la même adresse dans la tranche.

Cause fondamentale :

Le problème provient de l'affectation de la boucle de plage. à la variable 'stu.' Lorsque la boucle itère, 'stu' se voit attribuer une copie de l'élément slice à cet index. En conséquence, toutes les entrées de la carte font référence à la même valeur copiée.

Solution :

Pour résoudre ce problème, le code doit explicitement prendre l'adresse de chaque tranche élément avant de le stocker dans la carte :

for i := range s {
    m[s[i].Name] = &s[i]
}

En effectuant cette modification, chaque entrée de la carte fait désormais référence à l'adresse réelle de l'élément slice, garantissant le comportement attendu. Cela démontre l'importance de comprendre les nuances des boucles de plage de tranches et comment elles peuvent affecter la manipulation des données dans Go.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!