Nyahsulit Pergi: struct kosong

Dalam Go, struct biasa biasanya menduduki blok memori. Walau bagaimanapun, terdapat kes khas: jika ia adalah struct kosong, saiznya adalah sifar. Bagaimanakah ini boleh berlaku, dan apakah kegunaan struct kosong?

Artikel ini pertama kali diterbitkan dalam pelan MPP sederhana. Jika anda pengguna sederhana, sila ikuti saya dalam medium. Terima kasih banyak-banyak.

type Test struct {
    A int
    B string
}

func main() {
    fmt.Println(unsafe.Sizeof(new(Test)))
    fmt.Println(unsafe.Sizeof(struct{}{}))
}

/*
8
0
*/

Rahsia Struktur Kosong

Pembolehubah Khas: zerobase

Struktur kosong ialah struct tanpa saiz memori. Pernyataan ini betul, tetapi untuk menjadi lebih tepat, ia sebenarnya mempunyai titik permulaan yang istimewa: pembolehubah zerobase. Ini ialah pembolehubah global uintptr yang menduduki 8 bait. Apabila pembolehubah struct {} yang tidak terkira banyaknya ditakrifkan, pengkompil memberikan alamat pembolehubah zerobase ini. Dalam erti kata lain, dalam Go, sebarang peruntukan memori dengan saiz 0 menggunakan alamat yang sama, &zerobase.

Contoh

package main

import "fmt"

type emptyStruct struct {}

func main() {
    a := struct{}{}
    b := struct{}{}
    c := emptyStruct{}

    fmt.Printf("%p\n", &a)
    fmt.Printf("%p\n", &b)
    fmt.Printf("%p\n", &c)
}

// 0x58e360
// 0x58e360
// 0x58e360

Alamat memori pembolehubah struct kosong semuanya sama. Ini kerana pengkompil memperuntukkan &zerobase semasa penyusunan apabila menghadapi jenis peruntukan memori khas ini. Logik ini terdapat dalam fungsi mallocgc:

//go:linkname mallocgc  
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {  
    ...
    if size == 0 {  
       return unsafe.Pointer(&zerobase)  
    }
    ...

Ini adalah rahsia struct Kosong. Dengan pembolehubah istimewa ini, kami boleh mencapai banyak fungsi.

Struktur Kosong dan Penjajaran Ingatan

Biasanya, jika struct kosong adalah sebahagian daripada struct yang lebih besar, ia tidak mengisi memori. Walau bagaimanapun, terdapat kes khas apabila struct kosong ialah medan terakhir; ia mencetuskan penjajaran ingatan.

Contoh

type A struct {
    x int
    y string
    z struct{}
}
type B struct {
    x int
    z struct{}
    y string
}

func main() {
    println(unsafe.Alignof(A{}))
    println(unsafe.Alignof(B{}))
    println(unsafe.Sizeof(A{}))
    println(unsafe.Sizeof(B{}))
}

/**
8
8
32
24
**/

Apabila penunjuk ke medan hadir, alamat yang dikembalikan mungkin berada di luar struct, yang berpotensi membawa kepada kebocoran memori jika memori tidak dibebaskan apabila struct dilepaskan. Oleh itu, apabila struct kosong adalah medan terakhir struct lain, memori tambahan diperuntukkan untuk keselamatan. Jika struct kosong berada di permulaan atau tengah, alamatnya adalah sama dengan pembolehubah seterusnya.

type A struct {  
    x int  
    y string  
    z struct{}  
}  
type B struct {  
    x int  
    z struct{}  
    y string  
}  

func main() {  
    a := A{}  
    b := B{}  
    fmt.Printf("%p\n", &a.y)  
    fmt.Printf("%p\n", &a.z)  
    fmt.Printf("%p\n", &b.y)  
    fmt.Printf("%p\n", &b.z)  
}

/**
0x1400012c008
0x1400012c018
0x1400012e008
0x1400012e008
**/

Gunakan Kes Struktur Kosong

Sebab teras kewujudan struct struct kosong{} adalah untuk menjimatkan memori. Apabila anda memerlukan struct tetapi tidak mengambil berat tentang kandungannya, pertimbangkan untuk menggunakan struct kosong. Struktur komposit teras Go seperti peta, chan dan slice semuanya boleh menggunakan struct{}.

peta & struktur{}

// Create map
m := make(map[int]struct{})
// Assign value
m[1] = struct{}{}
// Check if key exists
_, ok := m[1]

chan & struct{}

Senario klasik menggabungkan saluran dan struct{}, di mana struct{} sering digunakan sebagai isyarat tanpa mengambil berat tentang kandungannya. Seperti yang dianalisis dalam artikel sebelumnya, struktur data penting saluran ialah struktur pengurusan ditambah penimbal cincin. Penampan gelang diperuntukkan sifar jika struct{} digunakan sebagai elemen.

Satu-satunya penggunaan chan dan struct{} bersama-sama adalah untuk penghantaran isyarat memandangkan struct kosong itu sendiri tidak boleh membawa sebarang nilai. Secara amnya, ia digunakan tanpa saluran penimbal.

// Create a signal channel
waitc := make(chan struct{})

// ...
goroutine 1:
    // Send signal: push element
    waitc <- struct{}{}
    // Send signal: close
    close(waitc)

goroutine 2:
    select {
    // Receive signal and perform corresponding actions
    case <-waitc:
    }    

Dalam senario ini, adakah struct{} amat diperlukan? Tidak begitu, dan memori yang disimpan boleh diabaikan. Perkara utama ialah nilai elemen chan tidak dipedulikan, justeru struct{} digunakan.

Ringkasan

1. Struktur kosong masih struct, hanya dengan saiz 0.
2. Semua struct kosong berkongsi alamat yang sama: alamat zerobase.
3. Kami boleh memanfaatkan ciri bukan-memori-menduduki struct kosong untuk mengoptimumkan kod, seperti menggunakan peta untuk melaksanakan set dan saluran.

Rujukan

1. Struktur kosong, Dave Cheney
2. Pergi 最细节篇— struct{} 空结构体究竟是啥？

Atas ialah kandungan terperinci Nyahsulit Pergi: struct kosong. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!