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

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 ?

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.

Résumé :

• make et new sont toutes deux des fonctions intégrées utilisées par golang pour allouer de la mémoire et allouer de la mémoire sur le tas. make alloue de la mémoire et initialise la mémoire. new efface uniquement la mémoire et n'initialise pas la mémoire.
• make renvoie le type de référence lui-même ; tandis que new renvoie un pointeur vers le type.
• make ne peut être utilisé que pour allouer et initialiser des données de types slice, map et channel ; new peut allouer n'importe quel type de données.

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!