struct基础

以下是针对每个问题的详细解答，涵盖基础、高级特性和底层原理：

一、基础概念

1. 结构体定义与初始化

定义：

type User struct {
    ID   int
    Name string
}

初始化方式：
- 值初始化：u := User{ID: 1, Name: "Alice"}
- 指针初始化：u := &User{ID: 2, Name: "Bob"}
- new 关键字：u := new(User)（返回指针，字段为默认零值）
new(Struct) vs &Struct{}：
- new(Struct) 返回指针，字段初始化为零值。
- &Struct{} 可在初始化时直接赋值字段，更灵活（如 &User{ID: 3}）。

使用 new 函数给一个新的结构体变量分配内存，它返回指向已分配内存的指针：var t *T = new(T)

下图说明了结构体类型实例和一个指向它的指针的内存布局：

使用 new 初始化：

作为结构体字面量初始化：

2. 零值与默认值

零值规则：
- 数值类型为 0，字符串为 ""，布尔为 false，指针/引用类型为 nil。
设置默认值：
- 通过构造函数：
```
func NewUser() User {
    return User{Name: "Guest"} // Name 默认 "Guest"
}
```
- 避免直接修改结构体定义，保持零值语义。

3. 匿名结构体

定义：

data := struct {
    Code int
    Msg  string
}{
    Code: 200,
    Msg:  "OK",
}

应用场景：
- 临时解析 JSON：json.Unmarshal([]byte(), &data)
- 单元测试中快速构建测试数据。

4. 字段/属性注意事项和细节说明

1)字段声明语法同变量，示例：字段名字段类型

2)字段的类型可以为：基本类型、数组或引用类型

3)在创建一个结构体变量后，如果没有给字段赋值，都对应一个零值(默认值)，规则同前面讲的一样：

布尔类型是false，数值是0，字符串是""。

数组类型的默认值和它的元素类型相关，比如score [3]int则为[0,0,0]指针，slice和map的零值都是nil，即还没有分配空间。（在使用的时候要使用make才可以给其赋值和使用，切片 map必须先make才能使用）
type student struct {
	Name  string
	Age   int
	Score [5]float32
	ptr   *int
	slice []int
	map1  map[string]string
}
 
func main() {
	var s student
	fmt.Printf("%#v", s)
 
	//错误写法
	//s.slice[0] = 0
	//再次说明，使用切片的时候，一定要使用make
	s.slice = make([]int, 10)
 
	//使用map的时候一定要先make,错误的写法s.map1["key1"] = "key1"
	s.map1 = make(map[string]string, 5)
	s.map1["key1"] = "value1"
}

如果在使用引用类型的时候要先使用make分配空间

(4)不同结构体变量的字段是独立，互不影响，一个结构体变量字段的更改，不影响另外一个，

	s1 := s
	s1.Name = "xxx"

结构体类型是值类型。

当结构体里面属性为引用类型，那么第一件事情就是使用make，要不然代码会崩溃。结构体这种数据类型默认是值拷贝，也就是值类型。

二、内存与性能

4. 内存对齐

内存布局：
- 字段按定义顺序排列，但编译器会插入填充字节（Padding）确保对齐。
- 对齐值取决于字段类型的最大对齐值（如 int64 对齐值为 8 字节）。

优化示例：

原始结构体（12 字节）：

struct { a bool; b int32; c bool }
// 内存布局：bool(1) + padding(3) + int32(4) + bool(1) + padding(3)

优化后（8 字节）：

struct { b int32; a bool; c bool }
// 内存布局：int32(4) + bool(1) + bool(1) + padding(2)

结构体和它所包含的数据在内存中是以连续块的形式存在的，即使结构体中嵌套有其他的结构体，这在性能上带来了很大的优势

type Rect1 struct { Min, Max Point }
type Rect2 struct { Min, Max *Point }

5. 结构体与 GC 性能

指针字段的影响：
- 指针指向堆内存，增加 GC 扫描负担。
- 若结构体包含大量指针（如 []*int），可能降低 GC 效率。
优化建议：
- 尽量使用值类型（如 int 而非 *int）。
- 对象池化（如 sync.Pool）减少堆分配。

6. 空结构体

特性：
- struct{} 不占用内存（大小为 0）。
- 所有 struct{} 实例地址相同（如 zerobase）。

应用场景：

实现 Set：

set := make(map[string]struct{})
set["key"] = struct{}{}

通道信号：

done := make(chan struct{})
close(done) // 广播信号

三、高级特性

7. 组合与继承

组合实现：

type Animal struct { Name string }
func (a Animal) Speak() { fmt.Println(a.Name) }

type Dog struct {
    Animal // 匿名嵌套，方法自动提升
    Breed  string
}

d := Dog{Animal: Animal{Name: "Buddy"}, Breed: "Lab"}
d.Speak() // 调用提升方法

与继承的区别：
- Go 无继承，通过组合实现代码复用。
- 组合更灵活，避免层级过深的继承链。

8. 结构体标签（Struct Tags）

作用：
- 附加元数据，供反射或第三方库解析。

示例：

type User struct {
    ID   int    `json:"id" gorm:"primaryKey"`
    Name string `json:"name"`
}

json 包解析时使用 json 标签。
gorm 库通过标签定义数据库约束。

9. 结构体比较

先说结论：

在结构体字段包括slice,map,channel这三种不能比较的类型时，结构体无法进行比较

不同的结构体之间无法进行比较

可比较条件：
- 所有字段类型均为可比较类型（如基本类型、数组、指针等）。
- 若包含 slice、map、func 等不可比较类型，则结构体不可比较。
深度比较：
- 使用 reflect.DeepEqual(a, b)。
- 自定义 Equals 方法遍历字段比较。

Go 结构体有时候并不能直接比较，当其基本类型包含：slice、map、function 时，是不能比较的。若强行比较，就会导致出现直接报错的情况。
而指针引用，其虽然都是 new(string)，从表象来看是一个东西，但其具体返回的地址是不一样的

如果被要求一定要用结构体比较怎么办？这时候可以使用反射方法 reflect.DeepEqual，如下：

func main() {
    v1 := Value{Name: "煎鱼", GoodAt: []string{"炸", "煎", "蒸"}}
    v2 := Value{Name: "煎鱼", GoodAt: []string{"炸", "煎", "蒸"}}
    if reflect.DeepEqual(v1, v2) {
        fmt.Println("脑子进煎鱼了")
        return
    }

    fmt.Println("脑子没进煎鱼")
}

// 输出结果为 “脑子进煎鱼了”

相同类型的值是深度相等的，不同类型的值永远不会深度相等。
当数组值（array）的对应元素深度相等时，数组值是深度相等的。
当结构体（struct）值如果其对应的字段（包括导出和未导出的字段）都是深度相等的，则该值是深度相等的。
当函数（func）值如果都是零，则是深度相等；否则就不是深度相等。
当接口（interface）值如果持有深度相等的具体值，则深度相等。

四、实际应用

10. 方法接收者选择

值接收者：
- 适用于不修改结构体状态的只读方法。
- 方法调用时复制结构体。
指针接收者：
- 需修改结构体字段或结构体较大时使用。
- 副作用：方法可能意外修改外部引用（如传递指针时）。

11. 深拷贝与浅拷贝

浅拷贝：

copy := original // 值类型字段复制，引用类型共享

深拷贝实现：

序列化反序列化：

import "encoding/gob"
func DeepCopy(dst, src interface{}) error {
    buff := new(bytes.Buffer)
    enc := gob.NewEncoder(buff)
    dec := gob.NewDecoder(buff)
    if err := enc.Encode(src); err != nil { return err }
    return dec.Decode(dst)
}

第三方库（如 github.com/jinzhu/copier）。

12. 结构体与接口

实现接口：

type Writer interface { Write([]byte) (int, error) }

type FileWriter struct{}
func (f FileWriter) Write(data []byte) (int, error) { /*...*/ }

var w Writer = FileWriter{} // 结构体赋值给接口变量

底层机制：
- 接口变量存储动态类型和值的指针（若值接收者）或值（若指针接收者）。

五、底层原理

13. 运行时结构（runtime struct）

g 结构体：
- 表示 Goroutine，包含栈、状态、调度信息等。
m 结构体：
- 表示操作系统线程（Machine），与 g 绑定执行任务。

14. 结构体逃逸分析

分析命令：
```
go build -gcflags="-m" main.go
```

示例输出：

./main.go:10:6: moved to heap: user // 结构体逃逸到堆

优化建议：
- 减少指针传递，避免不必要的堆分配。

六、开放设计题

15. 设计模式与结构体

单例模式：

type Singleton struct{}
var instance *Singleton
var once sync.Once

func GetInstance() *Singleton {
    once.Do(func() { instance = &Singleton{} })
    return instance
}

16. 并发安全的结构体

线程安全缓存：

type SafeCache struct {
    mu   sync.RWMutex
    data map[string]string
}

func (c *SafeCache) Get(key string) string {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.data[key]
}

读多写少时用 RWMutex 提升性能。

七、实战陷阱

17. 未导出字段的反射修改

反射修改：

s := struct{ name string }{name: "Alice"}
v := reflect.ValueOf(&s).Elem()
f := v.FieldByName("name")
if f.CanSet() {
    f.SetString("Bob") // 无法修改未导出字段（panic）
}

不安全，需谨慎操作。

18. 结构体循环依赖

解决方案：

将共同依赖抽离到第三方包。

使用接口解耦：

// package a
type B interface { Method() }
type A struct { B }

// package b
type BImpl struct { A *a.A }
func (b BImpl) Method() { /*...*/ }

八、进阶追问

19. 结构体与 CGO

传递结构体到 C：

/*
#include <stdio.h>
typedef struct { int id; } User;
void PrintUser(User u) { printf("%d\n", u.id); }
*/
import "C"

func main() {
    u := C.User{id: 100}
    C.PrintUser(u)
}

注意字段类型匹配（如 C.int vs int）。

20. 结构体内联优化

内联条件：
- 方法简单（如少于 40 行，无复杂控制流）。
- 编译器决定，可通过 -gcflags="-m" 查看日志：
```
./main.go:20:6: can inline User.GetName
```

总结

以上问题覆盖了从语法到运行时机制的全方位考察，实际回答时需结合代码示例和性能优化经验。深入理解这些问题，可显著提升代码质量和面试表现。

posted @ 2025-03-03 02:04 搁浅~浅浅浅阅读(116) 评论(0) 收藏举报

刷新页面返回顶部

gqfx

struct基础

一、基础概念

1. 结构体定义与初始化

2. 零值与默认值

3. 匿名结构体

4. 字段/属性注意事项和细节说明

二、内存与性能

4. 内存对齐

5. 结构体与 GC 性能

6. 空结构体

三、高级特性

7. 组合与继承

8. 结构体标签（Struct Tags）

9. 结构体比较

先说结论：

四、实际应用

10. 方法接收者选择

11. 深拷贝与浅拷贝

12. 结构体与接口

五、底层原理

13. 运行时结构（runtime struct）

14. 结构体逃逸分析

六、开放设计题

15. 设计模式与结构体

16. 并发安全的结构体

七、实战陷阱

17. 未导出字段的反射修改

18. 结构体循环依赖

八、进阶追问

19. 结构体与 CGO

20. 结构体内联优化

总结

公告

gqfx

struct基础

一、基础概念

1. 结构体定义与初始化

2. 零值与默认值

3. 匿名结构体

4. 字段/属性 注意事项和细节说明

二、内存与性能

4. 内存对齐

5. 结构体与 GC 性能

6. 空结构体

三、高级特性

7. 组合与继承

8. 结构体标签（Struct Tags）

9. 结构体比较

先说结论：

四、实际应用

10. 方法接收者选择

11. 深拷贝与浅拷贝

12. 结构体与接口

五、底层原理

13. 运行时结构（runtime struct）

14. 结构体逃逸分析

六、开放设计题

15. 设计模式与结构体

16. 并发安全的结构体

七、实战陷阱

17. 未导出字段的反射修改

18. 结构体循环依赖

八、进阶追问

19. 结构体与 CGO

20. 结构体内联优化

总结

公告

4. 字段/属性注意事项和细节说明