Perbezaan: 1. Make hanya boleh digunakan untuk memperuntukkan dan memulakan data jenis slice, map dan chan manakala baharu boleh memperuntukkan sebarang jenis data. 2. Peruntukan baru mengembalikan penunjuk, iaitu jenis "*Jenis" manakala membuat pulangan rujukan, iaitu Jenis. 3. Ruang yang diperuntukkan oleh baru akan dikosongkan selepas membuat memperuntukkan ruang, ia akan dimulakan.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

baharu dan buat adalah primitif untuk peruntukan memori dalam bahasa Go. Ringkasnya, baru hanya memperuntukkan memori, dan make digunakan untuk memulakan hirisan, peta dan saluran.

baharu

fungsi baru(T) ialah fungsi terbina dalam yang memperuntukkan memori untuk setiap jenis dan memulakannya kepada nilai sifar dan mengembalikan alamat memorinya. Sintaks

ialah func new(Type) *Type

Seperti yang kita sedia maklum, pembolehubah sedia ada boleh ditetapkan pada penudingnya.

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

Jadi bagaimana jika ia belum pembolehubah lagi? Bolehkah anda menetapkannya secara langsung?

func main() {
	var v *int
	*v = 8
	fmt.Println(*v)

	// panic: runtime error: invalid memory address or nil pointer dereference
	// [signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x47df36]

	// goroutine 1 [running]:
	// main.main()
	// 	/tmp/sandbox1410772957/prog.go:9 +0x16
}

Hasil ralat adalah seperti yang ditunjukkan dalam ulasan dalam kod.

Bagaimana untuk menyelesaikannya? Ini boleh diselesaikan dengan Go menyediakan alamat permulaan baharu.

func main() {
	var v *int
	// v 是一個 int 類型的指針，v 的地址和 v 的值  0xc0000ba018 <nil>
	fmt.Println("v 是一個 int 類型的指針，v 的地址和 v 的值 ", &v, v)   
	// 分配給 v 一個指向的變量             
	v = new(int)    
	// v 是一個 int 類型的指針，v 的地址和 v 的值  0xc0000ba018 0xc000018030 0，此時已經(jīng)分配給了 v 指針一個指向的變量，但是變量為零值                                                  
	fmt.Println("v 是一個 int 類型的指針，v 的地址， v 的值和 v 指向的變量的值 ", &v, v, *v) 
	*v = 8
	// v 是一個 int 類型的指針，v 的地址和 v 的值  0xc0000ba018 0xc000018030 8，此時又像這個變量中裝填了一個值 8
	fmt.Println("v 是一個 int 類型的指針，v 的地址， v 的值和 v 指向的變量的值 ", &v, v, *v) 
	
	// 整個過程可以理解為給 v 指針指向了一個匿名變量
}

Kita dapat melihat bahawa memulakan pembolehubah penunjuk dengan nilai sifar bukanlah tugasan langsung. Melalui baharu, penunjuk dengan nilai 0xc000018030 dikembalikan, menunjuk kepada jenis int yang baru ditetapkan dan nilai sifar ialah nilainya.

Selain itu, adalah penting untuk ambil perhatian bahawa nilai sifar adalah berbeza untuk jenis penunjuk yang berbeza. Untuk butiran, anda boleh rujuk artikel ini. Atau anda boleh menyemak imbas kod di bawah.

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

Di atas menerangkan cara menetapkan nilai selepas memproses jenis biasa new(). Tetapi di sini, saya rasa penulis artikel asal salah, kerana untuk slice, map dan channel, new hanya boleh membuka

array instance

func main() {
	// 聲明一個數(shù)組指針
	var a *[5]int
	fmt.Printf("a: %p %#v \n", &a, a) //a: 0xc04200a180 [5]int{0, 0, 0, 0, 0}
	// 分配一個內(nèi)存地址給 a（數(shù)組指針）指向
	a = new([5]int)
	fmt.Printf("a: %p %#v \n", &a, a) //av: 0xc000074018 &[5]int{0, 0, 0, 0, 0}
	// 修改這個數(shù)組中的值
	(*a)[1] = 8
	fmt.Printf("a: %p %#v \n", &a, a) //av: 0xc000006028 &[5]int{0, 8, 0, 0, 0}
}

structure instance

type mystruct struct {
	name string
	age  int
}

func main() {
	var people *mystruct
	people = new(mystruct)
	people.name = "zhangsan"
	people.age = 11

	fmt.Printf("%v, %v", people.name, people.age) // zhangsan, 11
}

make

make digunakan khas untuk mencipta tiga jenis peruntukan kandungan: chan, map dan slice serta boleh memulakannya. Jenis pulangan make adalah jenis yang sama dengan hujahnya, bukan penunjuk kepadanya, kerana ketiga-tiga jenis data ini adalah jenis rujukan sendiri.

Sintaksnya ialah: func make(t Type, size ...IntegerType) Type Anda boleh melihat bahawa parameter kedua ialah parameter panjang boleh ubah, yang digunakan untuk menentukan saiz memori yang diperuntukkan, contohnya, untuk kepingan, anda perlu menentukan topi dan panjang (topi mewakili kapasiti, panjang Menunjukkan panjang, iaitu saiz yang boleh digunakan), dan topi dikehendaki lebih besar daripada panjang.

Saya tidak akan memperkenalkan terlalu banyak tentang penutup dan panjang kepingan di sini Anda boleh memahami bahawa rumah ini adalah rumah yang kasar. Ia mempunyai 3 bilik telah dihias 1 bilik (panjang).

Mengapa tidak menggunakan baru untuk memperuntukkan memori untuk ketiga-tiga jenis ini? Jom buat eksperimen.

func main() {
	var s *[]int
	fmt.Printf("s 的地址是： %p, s 的值是 %p\n", &s, s) // s 的地址是： 0xc00000e028, s 的值是 0x0
	s = new([]int)
	fmt.Printf("s 的地址是： %p, s 的值是 %p\n", &s, s) // s 的地址是： 0xc00000e028, s 的值是 0xc00011a018
	(*s)[0] = 1
	fmt.Println("s 的地址是： %p, s 的值是 %p\n", &s, s) // panic: runtime error: index out of range [0] with length 0
}
}

Anda boleh melihat bahawa panjangnya adalah 0 apabila memberikan nilai kepada kepingan Bagi sebab tertentu, rakan-rakan yang mengetahuinya boleh meninggalkan mesej di ruang komen.

Oleh itu, selalunya disyorkan untuk menggunakan make untuk ketiga-tiga jenis ciptaan ini.

contoh kepingan

func main() {
	// 第一個 size 是 length，第二個 size 是 cap
	a := make([]int, 5, 10)
	// a: 0xc00011a018 []int{0, 0, 0, 0, 0}，cap: 10, length: 5 
	fmt.Printf("a: %p %#v，cap: %d, length: %d \n", &a, a, cap(a), len(a)) 
}

contoh peta

func main() {
	// 第一個 string 是 key，第二個 string 是 value
	mapInstance := make(map[string]string, 5)
	mapInstance["第一名"] = "張三"
	mapInstance["第二名"] = "李四"
	mapInstance["第三名"] = "王五"

	fmt.Println(mapInstance) // map[第一名:張三 第三名:王五 第二名:李四]
}

contoh saluran

func countNum(temp int, ch chan int) {
	i := temp + 1
	ch <- i
	fmt.Println("已經(jīng)將 i 發(fā)往通道 c 中")
}

func main() {
	ch := make(chan int)
	go countNum(1, ch)
	res := <-ch
	fmt.Println("已經(jīng)從 ch 中獲取 i 并保存在 res 中")
	fmt.Println("res 是", res)
}

Ringkasan:

Fungsi make hanya digunakan untuk peta, potong dan saluran, dan tidak mengembalikan penunjuk. Jika anda ingin mendapatkan penunjuk eksplisit, anda boleh menggunakan fungsi baharu untuk memperuntukkan, atau secara eksplisit menggunakan alamat pembolehubah.

Perbezaan utama antara baharu dan buat dalam bahasa Go adalah seperti berikut:

• make hanya boleh digunakan untuk memperuntukkan dan memulakan data jenis slice, map dan chan ; baru boleh memperuntukkan Sebarang jenis data.

• peruntukan baharu mengembalikan penunjuk, iaitu jenis *Jenis; membuat pulangan rujukan, iaitu Jenis.

• Ruang yang diperuntukkan oleh baru dikosongkan; selepas membuat memperuntukkan ruang, ia akan dimulakan.

[Cadangan berkaitan: Pergi tutorial video, Pengajaran pengaturcaraan]

Atas ialah kandungan terperinci Apakah perbezaan antara buat dan baharu dalam bahasa go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!