Go语言学习笔记21：结构体（struct）

1 结构体的核心概念

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

1.1 定义与声明

type struct_variable_type struct {
    member definition
    member definition
    ……
    member definition
}
// 一旦定义了结构体类型，它就能用于变量的声明

// 基础定义
type User struct {
    ID       int
    Username string
    Email    string
    isActive bool    // 小写字段，仅包内可访问
}

// 嵌套结构体
type Address struct {
    City  string
    Street string
}

type Customer struct {
    User    // 匿名嵌入
    Addr    Address  // 具名字段
    VIPLevel int
}

1.2 初始化方式

// 零值初始化
var u1 User

// 字段顺序初始化
u2 := User{1, "Alice", "alice@example.com", true}

// 命名字段初始化（推荐）
u3 := User{
    ID:       2,
    Username: "Bob",
    Email:    "bob@example.com",
}

// new关键字（返回指针）
u4 := new(User)
u4.Username = "Charlie"

// 嵌套结构体初始化
cust := Customer{
    User: User{ID: 3, Username: "Dave"},
    Addr: Address{City: "Beijing"},
}

2 结构体的内存布局

2.1 字段对齐规则

• 遵循自然对齐原则，字段按类型大小对齐
• 内存占用公式：Sizeof(struct) = 各字段大小 + 填充字节

type Example struct {
    a bool    // 1字节
              // 7字节填充（假设64位系统）
    b int64   // 8字节
    c int32   // 4字节
              // 4字节填充
}
// 总大小：1 +7(pad) +8 +4 +4(pad) =24字节

2.2 优化技巧

• 字段重排序减少填充：

// 优化前：24字节
type Bad struct {
    a bool
    b int64
    c int32
}

// 优化后：16字节
type Good struct {
    b int64
    c int32
    a bool
}

3 结构体方法

3.1 值接收者 vs 指针接收者

type Counter struct {
    count int
}

// 值接收者（不影响原对象）
func (c Counter) IncByValue() {
    c.count++
}

// 指针接收者（修改原对象）
func (c *Counter) IncByPointer() {
    c.count++
}

3.2 方法集规则

• 类型T的方法集包含所有值接收者方法
• 类型*T的方法集包含所有值接收者和指针接收者方法
• 影响接口实现：

type Incrementer interface {
    Inc()
}

// 只有*Counter实现接口
func (c *Counter) Inc() { ... }

4 结构体高级特性

4.1 匿名嵌入（Embedding）

• 类似继承的效果，实现组合复用
• 可直接访问嵌入类型的字段和方法

type Animal struct {
    Name string
}

func (a Animal) Speak() {
    fmt.Println("Animal sound")
}

type Dog struct {
    Animal         // 匿名嵌入
    Breed  string
}

func main() {
    d := Dog{Animal{"Buddy"}, "Husky"}
    d.Speak()      // 继承Animal的方法
    fmt.Println(d.Name)  // 直接访问嵌入字段
}

4.2 结构体标签（Tags）

• 元数据标注，常用于序列化/反序列化
• 通过反射reflect包读取

type User struct {
    ID    int    `json:"id" db:"user_id"`
    Name  string `json:"name" validate:"required"`
}

5 结构体与接口

5.1 空接口与类型断言

func process(v interface{}) {
    if u, ok := v.(User); ok {
        fmt.Println("User:", u.Name)
    }
}

5.2 实现接口

type Stringer interface {
    String() string
}

func (u User) String() string {
    return fmt.Sprintf("User[%d]: %s", u.ID, u.Name)
}

6 性能优化实践

6.1 避免大结构体拷贝

// 错误：传递大结构体副本
func ProcessUser(u User) { ... }

// 正确：传递指针
func ProcessUser(u *User) { ... }

6.2 使用结构体池

var userPool = sync.Pool{
    New: func() interface{} { return new(User) },
}

func GetUser() *User {
    return userPool.Get().(*User)
}

func PutUser(u *User) {
    u.Reset()
    userPool.Put(u)
}

7 典型应用场景

7.1 数据模型定义

// ORM模型
type Product struct {
    gorm.Model
    Name  string  `gorm:"size:255"`
    Price float64
}

7.2 配置管理

type Config struct {
    Server struct {
        Host string `yaml:"host"`
        Port int    `yaml:"port"`
    }
    Database struct {
        DSN string `yaml:"dsn"`
    }
}

8 注意事项总结

9 总结：结构体的核心价值

1. 数据封装：将相关数据字段组织为逻辑单元
2. 行为绑定：通过方法实现面向对象特性
3. 类型安全：编译器静态检查字段类型
4. 内存优化：通过合理设计减少内存占用
5. 接口实现：作为实现接口的具体类型

通过结构体可以构建：
– 数据库实体模型
– API请求/响应格式
– 配置参数集合
– 中间件上下文对象
– 算法数据结构（树、图等）