Go语言结构体切片初始化：make()与自定义构造函数的结合实践

package main

import "sync"

type Thing struct {
    lock *sync.RWMutex
    data chan int
}

// NewThing 是 Thing 结构体的构造函数
func NewThing() *Thing {
    return &Thing{lock: new(sync.RWMutex), data: make(chan int)}
}

func main() {
    n := 10
    things := make([]*Thing, n) // 此时 things 包含 10 个 nil *Thing 指针
    for i := 0; i < n; i++ {    // 注意：原代码中的 i < n 循环条件有误，应为 i < n
        things[i] = NewThing()  // 逐个调用构造函数进行初始化
    }
    // ... 后续操作
}

package main

import (
    "fmt"
    "sync"
)

// Thing 结构体定义，包含互斥锁和通道
type Thing struct {
    lock *sync.RWMutex
    data chan int
}

// NewThing 是 Thing 结构体的构造函数，负责初始化单个 Thing 实例
func NewThing() *Thing {
    return &Thing{lock: new(sync.RWMutex), data: make(chan int)}
}

// NewThings 是一个辅助函数，用于创建并初始化一个 Thing 结构体指针的切片
func NewThings(n int) []*Thing {
    // 使用 make() 分配一个长度为 n 的 []*Thing 切片
    // 此时切片中的所有元素都是 nil
    things := make([]*Thing, n) 

    // 遍历切片，为每个元素调用 NewThing 构造函数进行初始化
    // for i := range things 是 Go 语言中遍历切片索引的惯用方式
    for i := range things {
        things[i] = NewThing()
    }
    return things
}

func main() {
    // 调用 NewThings 辅助函数创建并初始化一个包含 3 个 Thing 实例的切片
    things := NewThings(3)

    fmt.Println("切片长度:", len(things))
    // 遍历并打印每个 Thing 实例的内存地址，验证它们已被正确初始化
    for i, thing := range things {
        fmt.Printf("things[%d]: %p, lock: %p, data: %p\n", i, thing, thing.lock, thing.data)
    }

    // 进一步验证内部字段是否已初始化（例如，通道不是 nil）
    // thing.data 是一个已初始化的通道，可以进行发送和接收操作
    if len(things) > 0 {
        firstThing := things[0]
        if firstThing.data != nil {
            fmt.Println("第一个 Thing 的数据通道已初始化。")
        }
    }
}

切片长度: 3
things[0]: 0xc000010210, lock: 0xc000010200, data: 0xc000012000
things[1]: 0xc000010220, lock: 0xc000010230, data: 0xc000012060
things[2]: 0xc000010240, lock: 0xc000010250, data: 0xc0000120c0
第一个 Thing 的数据通道已初始化。