L'importance des récepteurs de pointeurs lors de la copie d'instances

Lors de la manipulation de données, il est crucial de comprendre les nuances de la transmission de valeurs par référence ou par valeur. Dans Go, les méthodes peuvent être définies avec des récepteurs de valeur ou de pointeur, et il est essentiel de comprendre les implications de ce choix, en particulier lors de la copie d'instances.

Récepteurs de valeur

Les méthodes avec des récepteurs de valeur fonctionnent sur une copie de la valeur qu'elles reçoivent. Toute modification apportée à la méthode n’affectera pas la valeur d’origine. Cela garantit que l'appel des méthodes sur les instances copiées ne compromettra pas les données d'origine.

Récepteurs de pointeurs

À l'inverse, les méthodes avec des récepteurs de pointeurs permettent un accès direct et une modification de la valeur d'origine. . De telles méthodes peuvent potentiellement modifier les données, ce qui peut entraîner des effets secondaires subtils et involontaires. La copie d'instances avec des récepteurs de pointeurs comporte le risque d'introduire des incohérences entre les données originales et copiées.

Exemple : Wrapper Struct

Pour illustrer le problème, considérons un type appelé Wrapper. avec les champs v (valeur) et p (pointeur vers une valeur) :

type Wrapper struct {
    v int
    p *int
}

La méthode Set() avec un récepteur de pointeur modifie à la fois v et la valeur pointée :

func (w *Wrapper) Set(v int) {
    w.v = v
    *w.p = v
}

Supposons que nous ayons une instance Wrapper a:

a := Wrapper{v: 0, p: new(int)}

Calling Set() sur a modifiera à la fois v et *p :

a.Set(1)

Maintenant, si nous copions a pour créer b, nous nous attendons à ce que les deux instances aient des valeurs cohérentes :

b := a

Cependant, les modifications ultérieures apportées à a à l'aide de Set() ne se propageront pas à b en raison de la copie du pointeur p, ce qui entraînera des données incohérentes :

fmt.Printf("a.v=%d, a.p=%d;  b.v=%d, b.p=%d\n", a.v, *a.p, b.v, *b.p)
a.Set(1)
fmt.Printf("a.v=%d, a.p=%d;  b.v=%d, b.p=%d\n", a.v, *a.p, b.v, *b.p)

Sortie :

a.v=0, a.p=0;  b.v=0, b.p=0
a.v=1, a.p=1;  b.v=0, b.p=1

Conclusion

Lorsque vous traitez des types qui ont des méthodes avec des récepteurs de pointeurs, il est crucial d'éviter de copier des instances pour éviter les incohérences des données. Au lieu de cela, opérez sur les valeurs du pointeur pour garantir que les modifications sont reflétées dans toutes les instances qui font référence aux mêmes données sous-jacentes.