Comment convertir correctement une tranche de chaînes en une tranche de pointeurs de chaîne dans Go ?

Conversion d'une tranche de chaîne en tranche de pointeur en chaîne

En programmation, il est parfois nécessaire de convertir une tranche de valeurs de chaîne en tranche de pointeurs vers des chaînes. Cela peut être difficile lorsqu'il s'agit de gérer les nuances des références et de l'allocation de mémoire.

Problème d'origine

Considérez l'exemple suivant :

package main

import (
    "fmt"
)

func main() {
    values1 := []string{"a", "b", "c"}
    var values2 []*string
    for _, v := range values1 {
        fmt.Printf("%p | %T\n", v, v)
        values2 = append(values2, &v)
    }
    fmt.Println(values2)
}

Dans Dans cet exemple, nous nous attendons à créer une tranche de pointeurs (valeurs2) qui pointent vers les éléments de chaîne dans valeurs1. Cependant, le résultat révèle que tous les pointeurs pointent vers la même adresse, indiquant qu'ils font référence au même objet plutôt qu'à des chaînes distinctes :

%!p(string=a) => string
%!p(string=b) => string
%!p(string=c) => string
[0xc42000e1d0 0xc42000e1d0 0xc42000e1d0]

Comprendre le problème

Ce comportement se produit car la variable de boucle v est passée par valeur. À chaque itération, il reçoit une copie de la chaîne actuelle dans valeurs1, et ainsi, tous les pointeurs ajoutés à valeurs2 pointent vers la même copie de la chaîne.

Solution proposée

Pour résoudre ce problème, nous devons passer un pointeur vers l'élément chaîne dans valeurs1 à la variable de boucle. Une solution consiste à utiliser l'approche suivante :

for i, _ := range values1 {
    values2 = append(values2, &values1[i])
}

Ici, la variable de boucle i est utilisée pour indexer dans valeurs1, et l'adresse de l'élément indexé est ajoutée à valeurs2. Cela garantit que chaque pointeur dans valeurs2 pointe vers un élément de chaîne unique dans valeurs1.

Impact sur la gestion de la mémoire

Il est important de noter que même si la solution ci-dessus résout le pointeur problème, cela a des implications sur la gestion de la mémoire. La tranche valeurs2 contient des pointeurs vers les éléments de valeurs1, empêchant valeurs1 d'être récupérées jusqu'à ce que valeurs1 et valeurs2 deviennent inaccessibles. De plus, la modification d'éléments dans valeurs1 modifiera indirectement les éléments dans valeurs2, car ils pointent tous les deux vers les mêmes données.

Solution alternative

Une autre solution pour éviter les implications en matière de gestion de la mémoire consiste à créer des variables locales temporaires et à ajouter les adresses de celles-ci aux valeurs2 :

for _, v := range values1 {
    v2 := v
    values2 = append(values2, &v2)
}

Dans cette approche, chaque itération crée une nouvelle variable locale v2 et lui attribue la valeur de la chaîne actuelle dans valeurs1. L'adresse de v2 est ensuite ajoutée aux valeurs2. Cela garantit que chaque pointeur dans Values2 pointe vers un objet chaîne indépendant et que Values1 peut être récupéré indépendamment de Values2.

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!