Maison >développement back-end >Golang >Quelle est la différence entre make et new in go langage ?
Différence : dans le langage Go, make et new allouent tous deux de la mémoire (sur le tas), mais make n'est utilisé que pour l'initialisation de la tranche, de la carte et du canal (valeurs non nulles tandis que new est utilisé pour) ; types La mémoire est allouée et la mémoire est définie sur zéro. make renvoie le type de référence lui-même ; new renvoie un pointeur vers le type.
L'environnement d'exploitation de cet article : système Windows10, GO 1.11.2, ordinateur Thinkpad T480.
Recommandations associées : "tutoriel go"
Dans le langage Go, new et make sont toutes deux des primitives utilisées pour l'allocation de mémoire (primitives d'allocation). En termes simples, new alloue uniquement de la mémoire et make est utilisé pour l'initialisation de la tranche, de la carte et du canal. La fonction
new(T) est une fonction intégrée qui alloue de la mémoire.
Nous savons tous que pour une variable existante, son pointeur peut être attribué.
Exemple
var p int var v *int v = &p *v = 11 fmt.Println(*v)
Alors, et si ce n'est pas une variable qui existe déjà ? Peut-on lui attribuer directement une valeur ?
Exemple
var v *int *v = 8 fmt.Println(*v)
Le résultat sera l'erreur suivante
panique : erreur d'exécution : adresse mémoire invalide ou déréférencement de pointeur nul
[signal 0xc0000005 code=0x1 addr= 0x0 pc =0x48df66]
Comment le résoudre ? Cela peut être résolu en fournissant new par Go pour initialiser une adresse.
var v *int v = new(int) *v = 8 fmt.Println(*v)
Alors analysons
var v *int fmt.Println(*v) fmt.Println(v) //<nil> v = new(int) fmt.Println(*v)// fmt.Println(v)//0xc00004c088
Nous pouvons voir que l'initialisation d'une variable pointeur a une valeur nulle, et la valeur de nil ne peut pas être attribuée directement. Grâce à new, il renvoie un pointeur vers un type int nouvellement alloué. La valeur du pointeur est 0xc00004c088. La valeur du contenu pointé par ce pointeur est nulle.
Dans le même temps, il convient de noter que la valeur zéro des différents types de pointeurs est différente.
Exemple
type Name struct {
P string
}
var av *[5]int
var iv *int
var sv *string
var tv *Name
av = new([5]int)
fmt.Println(*av) //[0 0 0 0 0 0]
iv = new(int)
fmt.Println(*iv) // 0
sv = new(string)
fmt.Println(*sv) //
tv = new(Name)
fmt.Println(*tv) //{}
Ce qui précède décrit comment attribuer des valeurs aux types ordinaires après le traitement new(). Nous parlerons ici des types composites (tableau, tranche, carte, canal, etc. ), new( ), comment attribuer une valeur après le traitement.
Exemple de tableau
var a [5]int
fmt.Printf("a: %p %#v \n", &a, a)//a: 0xc04200a180 [5]int{0, 0, 0, 0, 0}
av := new([5]int)
fmt.Printf("av: %p %#v \n", &av, av)//av: 0xc000074018 &[5]int{0, 0, 0, 0, 0}
(*av)[1] = 8
fmt.Printf("av: %p %#v \n", &av, av)//av: 0xc000006028 &[5]int{0, 8, 0, 0, 0}
exemple de silce
var a *[]int
fmt.Printf("a: %p %#v \n", &a, a) //a: 0xc042004028 (*[]int)(nil)
av := new([]int)
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000074018 &[]int(nil)
(*av)[0] = 8
fmt.Printf("av: %p %#v \n", &av, av) //panic: runtime error: index out of range
exemple de carte
var m map[string]string
fmt.Printf("m: %p %#v \n", &m, m)//m: 0xc042068018 map[string]string(nil)
mv := new(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc000006028 &map[string]string(nil)
(*mv)["a"] = "a"
fmt.Printf("mv: %p %#v \n", &mv, mv)//这里会报错panic: assignment to entry in nil map
exemple de canal
cv := new(chan string)
fmt.Printf("cv: %p %#v \n", &cv, cv)//cv: 0xc000074018 (*chan string)(0xc000074020)
//cv <- "good" //会报 invalid operation: cv <- "good" (send to non-chan type *chan string)
À travers l'exemple ci-dessus, nous voyons que le array passe un nouveau traitement, le tableau av est initialisé avec une valeur nulle. Bien que le tableau soit un type composite, ce n'est pas un type de référence. Les autres types silce, map et channel sont également des types de référence. Go initialisera le type de référence à zéro. , et nul ne peut pas être attribué directement. Et vous ne pouvez pas utiliser new pour allouer de la mémoire. Ne peut pas être attribué directement. Alors, à quoi ressemblerait l’utilisation de la fonction make ?
Exemple
av := make([]int, 5)
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000046400 []int{0, 0, 0, 0, 0}
av[0] = 1
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000046400 []int{1, 0, 0, 0, 0}
mv := make(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv) //mv: 0xc000074020 map[string]string{}
mv["m"] = "m"
fmt.Printf("mv: %p %#v \n", &mv, mv) //mv: 0xc000074020 map[string]string{"m":"m"}
chv := make(chan string)
fmt.Printf("chv: %p %#v \n", &chv, chv) //chv: 0xc000074028 (chan string)(0xc00003e060)
go func(message string) {
chv <- message // 存消息
}("Ping!")
fmt.Println(<-chv) // 取消息 //"Ping!"
close(chv)
make peut non seulement ouvrir une mémoire, mais aussi initialiser sa valeur zéro pour le type de cette mémoire.
Il peut également être utilisé avec new
Exemple
var mv *map[string]string
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc042004028 (*map[string]string)(nil)
mv = new(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc000006028 &map[string]string(nil)
(*mv) = make(map[string]string)
(*mv)["a"] = "a"
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc042004028 &map[string]string{"a":"a"}
Allouez une mémoire à la variable de pointeur mv via new et attribuez-lui une adresse mémoire. Map est un type de référence et sa valeur zéro est nulle. Utilisez make pour initialiser map, puis la variable peut utiliser * pour attribuer une valeur à la variable de pointeur mv.
Pour plus de connaissances liées à la programmation, veuillez visiter : Enseignement de la programmation ! !
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!