Was ist der Unterschied zwischen make und new in der Go-Sprache?

Unterschied: In der Go-Sprache weisen make und new beide Speicher zu (auf dem Heap), aber make wird nur für die Initialisierung von Slice, Map und Channel (Werte ungleich Null) verwendet, während new für die Typspeicherzuweisung verwendet wird , und der Speicher wird auf Null gesetzt. make gibt den Referenztyp selbst zurück; new gibt einen Zeiger auf den Typ zurück.

Die Betriebsumgebung dieses Artikels: Windows 10-System, GO 1.11.2, Thinkpad T480-Computer.

Verwandte Empfehlungen: „go-Tutorial“

In der Go-Sprache sind new und make beide Grundelemente, die für die Speicherzuweisung verwendet werden (Zuweisungsgrundelemente). Einfach ausgedrückt: new weist nur Speicher zu und make wird für die Initialisierung von Slice, Map und Channel verwendet. Die Funktion

new

new(T) ist eine integrierte Funktion, die Speicher zuweist.

Wir alle wissen, dass für eine vorhandene Variable ihrem Zeiger ein Wert zugewiesen werden kann.

Beispiel

var p int
var v *int
v = &p
*v = 11
fmt.Println(*v)

Und was ist, wenn es sich nicht um eine Variable handelt, die bereits existiert? Kann ihm direkt ein Wert zugewiesen werden?

Beispiel

var v *int
*v = 8
fmt.Println(*v)

Das Ergebnis wird der folgende Fehler sein

Panik: Laufzeitfehler: ungültige Speicheradresse oder Nullzeiger-Dereferenzierung
[Signal 0xc0000005 Code=0x1 Addr=0x0 PC=0x48df66]

Wie löst man das Problem? Dies kann gelöst werden, indem Go new bereitstellt, um eine Adresse zu initialisieren.

var v *int
v = new(int)
*v = 8
fmt.Println(*v)

Dann analysieren wir

var v *int
	fmt.Println(*v)
fmt.Println(v) //<nil>
v = new(int) 
fmt.Println(*v)//
fmt.Println(v)//0xc00004c088

Wir können sehen, dass bei der Initialisierung einer Zeigervariablen ihr Wert Null ist und der Wert Null nicht direkt zugewiesen werden kann. Durch new wird ein Zeiger auf einen neu zugewiesenen Typ int zurückgegeben. Der Zeigerwert ist 0xc00004c088. Der Wert des Inhalts, auf den dieser Zeiger zeigt, ist der Wert Null.

Gleichzeitig ist zu beachten, dass der Nullwert verschiedener Zeigertypen unterschiedlich ist.

Beispiel

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) //{}

Oben wird beschrieben, wie Werte nach der Verarbeitung von new() für gewöhnliche Typen zugewiesen werden. Hier werden wir darüber sprechen, wie Werte nach der Verarbeitung von new() für zusammengesetzte Typen (Array, Slice, Map,) zugewiesen werden. Kanal usw.).

Array-Beispiel

	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}

silce-Beispiel

	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

map-Beispiel

	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

channel-Beispiel

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)

Anhand des obigen Beispiels sehen wir, dass das Array durch new verarbeitet wird und das Array av mit dem Wert Null initialisiert wird. Obwohl das Array ist ein zusammengesetzter Typ und kein Referenztyp. Andere Silence-, Map- und Channel-Typen sind ebenfalls Referenztypen. Go initialisiert den Referenztyp auf Null und kann nicht direkt zugewiesen werden. Und Sie können new nicht zum Zuweisen von Speicher verwenden. Kann nicht direkt zugeordnet werden. Wie wäre es also, die Make-Funktion zu verwenden?

make

Beispiel

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 kann nicht nur einen Speicher öffnen, sondern auch seinen Nullwert für den Typ dieses Speichers initialisieren.

Es kann auch zusammen mit new verwendet werden

Beispiel

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"}

Ordnen Sie der Zeigervariablen mv über new einen Speicher zu und weisen Sie ihr eine Speicheradresse zu. Map ist ein Referenztyp und sein Nullwert ist Null. Verwenden Sie make, um die Map zu initialisieren, und dann kann der Variablen mit * ein Wert der Zeigervariablen mv zugewiesen werden.

Zusammenfassung:

• make und new sind beide integrierte Funktionen, die von Golang zum Zuweisen von Speicher verwendet werden. Durch das Zuweisen von Speicher auf dem Heap wird Speicher zugewiesen und der Speicher initialisiert. new löscht nur den Speicher und initialisiert ihn nicht.
• make gibt den Referenztyp selbst zurück, während new einen Zeiger auf den Typ zurückgibt.
• make kann nur zum Zuweisen und Initialisieren von Daten der Typen Slice, Map und Channel verwendet werden; new kann jeden Datentyp zuordnen.

Weitere Kenntnisse zum Thema Programmierung finden Sie unter: Programmierunterricht! !

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen make und new in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!