Aller à l'allocation de mémoire : quand dois-je utiliser « new() » plutôt que « & » ?

Au-delà de l'allocation : explorer les distinctions entre new() et allocation régulière

Dans Go, la gestion de la mémoire est de la plus haute importance et l'allocation de mémoire via la fonction new() ou l'esperluette (&) a alimenté les débats sur l'efficacité et la précision. Cet article approfondira les nuances de ces deux méthodes d'allocation, en examinant leurs similitudes et leurs différences potentielles.

new() vs. Allocation régulière : un examen plus approfondi

À première vue, les extraits de code que vous avez fournis peuvent sembler indiscernables :

v := &Vector{}

contre

v := new(Vector)

Cependant, une inspection plus approfondie révèle qu'ils partagent un point commun : la valeur renvoyée dans les deux cas est un pointeur vers une nouvelle instance de la structure Vector. Cela ressort clairement de l'exemple de code suivant :

package main

import "fmt"
import "reflect"

type Vector struct {
    x   int
    y   int
}

func main() {
    v := &Vector{}
    x := new(Vector)
    fmt.Println(reflect.TypeOf(v))
    fmt.Println(reflect.TypeOf(x))
}

Sortie :

*main.Vector
*main.Vector

Comme indiqué, les deux méthodes renvoient des pointeurs vers des instances de la structure Vector.

Le Confusion Conundrum

L'existence à la fois de new() et d'allocation régulière a semé la confusion au sein de la communauté Go. Certains soutiennent qu’il n’est pas nécessaire d’avoir les deux options, ce qui pourrait conduire à des malentendus. Ce débat était répandu sur la liste de diffusion Go :

[https://groups.google.com/forum/?fromgroups=#!topic/golang-nuts/GDXFDJgKKSs](https://groups.google .com/forum/?fromgroups=#!topic/golang-nuts/GDXFDJgKKSs)

Différences notables : un Exception

Bien que le consensus général soit que l'allocation new() et régulière donne des résultats similaires, il existe une exception notable. Lorsque vous travaillez avec des types entiers sans nom ou d'autres types de base, new() devient la seule option pour obtenir un pointeur. Le code suivant le démontre :

p := new(int)
// Error: cannot take the address of the type int
p := &int{0}

Dans ce scénario, new() est la seule méthode qui permet la création d'un pointeur vers un type entier sans nom.

Conclusion

Bien qu'il n'y ait pas de différence significative entre new() et l'allocation régulière en termes de valeur renvoyée, leur présence peut introduire de la confusion. Cependant, se rappeler que new() est essentiel lorsqu'il s'agit de pointeurs vers des entiers sans nom ou des types de base peut aider à clarifier leur utilisation et à éviter des pièges potentiels. En comprenant les subtilités des techniques de gestion de la mémoire dans Go, les développeurs peuvent optimiser leur code pour plus d'efficacité et de clarté.

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!