Apakah perbezaan antara buat dan baharu dalam bahasa go

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，此时已经分配给了 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() {
	// 声明一个数组指针
	var a *[5]int
	fmt.Printf("a: %p %#v \n", &a, a) //a: 0xc04200a180 [5]int{0, 0, 0, 0, 0}
	// 分配一个内存地址给 a（数组指针）指向
	a = new([5]int)
	fmt.Printf("a: %p %#v \n", &a, a) //av: 0xc000074018 &[5]int{0, 0, 0, 0, 0}
	// 修改这个数组中的值
	(*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("已经将 i 发往通道 c 中")
}

func main() {
	ch := make(chan int)
	go countNum(1, ch)
	res := <-ch
	fmt.Println("已经从 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!