987 lines
22 KiB
Go
987 lines
22 KiB
Go
/*
|
||
05-pointers.go - Go 语言指针详解
|
||
|
||
学习目标：
|
||
1. 理解指针的概念和作用
|
||
2. 掌握指针的声明和使用
|
||
3. 学会指针的运算和操作
|
||
4. 了解指针与函数参数的关系
|
||
5. 掌握指针的实际应用场景
|
||
|
||
知识点：
|
||
- 指针的定义和特性
|
||
- 指针的声明和初始化
|
||
- 取地址操作符 &
|
||
- 解引用操作符 *
|
||
- 指针与函数参数
|
||
- 指针与结构体
|
||
- 指针的零值 nil
|
||
- 指针的安全使用
|
||
*/
|
||
|
||
package main
|
||
|
||
import (
|
||
"fmt"
|
||
)
|
||
|
||
func main() {
|
||
fmt.Println("=== Go 语言指针详解 ===\n")
|
||
|
||
// 演示指针的基本概念
|
||
demonstrateBasicPointers()
|
||
|
||
// 演示指针的操作
|
||
demonstratePointerOperations()
|
||
|
||
// 演示指针与函数
|
||
demonstratePointersWithFunctions()
|
||
|
||
// 演示指针与结构体
|
||
demonstratePointersWithStructs()
|
||
|
||
// 演示指针与数组/切片
|
||
demonstratePointersWithArraysSlices()
|
||
|
||
// 演示指针的高级用法
|
||
demonstrateAdvancedPointerUsage()
|
||
|
||
// 演示指针的实际应用
|
||
demonstratePracticalApplications()
|
||
}
|
||
|
||
// demonstrateBasicPointers 演示指针的基本概念
|
||
func demonstrateBasicPointers() {
|
||
fmt.Println("1. 指针的基本概念:")
|
||
|
||
// 指针的基本特性
|
||
fmt.Printf(" 指针的基本特性:\n")
|
||
fmt.Printf(" - 存储变量的内存地址\n")
|
||
fmt.Printf(" - 通过地址间接访问变量\n")
|
||
fmt.Printf(" - 零值是 nil\n")
|
||
fmt.Printf(" - 类型安全，不支持指针运算\n")
|
||
fmt.Printf(" - 自动垃圾回收管理\n")
|
||
|
||
// 基本指针示例
|
||
fmt.Printf(" 基本指针示例:\n")
|
||
|
||
// 声明变量
|
||
var x int = 42
|
||
fmt.Printf(" 变量 x: %d\n", x)
|
||
fmt.Printf(" x 的地址: %p\n", &x)
|
||
|
||
// 声明指针
|
||
var p *int
|
||
fmt.Printf(" 指针 p 的零值: %v\n", p)
|
||
fmt.Printf(" p == nil: %t\n", p == nil)
|
||
|
||
// 指针赋值
|
||
p = &x
|
||
fmt.Printf(" p = &x 后:\n")
|
||
fmt.Printf(" p 的值（地址）: %p\n", p)
|
||
fmt.Printf(" p 指向的值: %d\n", *p)
|
||
fmt.Printf(" p 的地址: %p\n", &p)
|
||
|
||
// 通过指针修改值
|
||
*p = 100
|
||
fmt.Printf(" *p = 100 后:\n")
|
||
fmt.Printf(" x 的值: %d\n", x)
|
||
fmt.Printf(" *p 的值: %d\n", *p)
|
||
|
||
// 指针的类型
|
||
fmt.Printf(" 指针的类型:\n")
|
||
var intPtr *int
|
||
var floatPtr *float64
|
||
var stringPtr *string
|
||
|
||
fmt.Printf(" *int 指针: %T\n", intPtr)
|
||
fmt.Printf(" *float64 指针: %T\n", floatPtr)
|
||
fmt.Printf(" *string 指针: %T\n", stringPtr)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePointerOperations 演示指针的操作
|
||
func demonstratePointerOperations() {
|
||
fmt.Println("2. 指针的操作:")
|
||
|
||
// 取地址操作符 &
|
||
fmt.Printf(" 取地址操作符 &:\n")
|
||
|
||
a := 10
|
||
b := 20
|
||
c := 30
|
||
|
||
fmt.Printf(" 变量地址:\n")
|
||
fmt.Printf(" &a: %p\n", &a)
|
||
fmt.Printf(" &b: %p\n", &b)
|
||
fmt.Printf(" &c: %p\n", &c)
|
||
|
||
// 解引用操作符 *
|
||
fmt.Printf(" 解引用操作符 *:\n")
|
||
|
||
ptr := &a
|
||
fmt.Printf(" ptr 指向 a: %p\n", ptr)
|
||
fmt.Printf(" *ptr: %d\n", *ptr)
|
||
|
||
// 修改指针指向
|
||
ptr = &b
|
||
fmt.Printf(" ptr 指向 b: %p\n", ptr)
|
||
fmt.Printf(" *ptr: %d\n", *ptr)
|
||
|
||
// 指针赋值
|
||
fmt.Printf(" 指针赋值:\n")
|
||
|
||
var p1, p2 *int
|
||
p1 = &a
|
||
p2 = p1 // 指针赋值，两个指针指向同一地址
|
||
|
||
fmt.Printf(" p1: %p, *p1: %d\n", p1, *p1)
|
||
fmt.Printf(" p2: %p, *p2: %d\n", p2, *p2)
|
||
fmt.Printf(" p1 == p2: %t\n", p1 == p2)
|
||
|
||
// 通过不同指针修改同一变量
|
||
*p1 = 99
|
||
fmt.Printf(" *p1 = 99 后:\n")
|
||
fmt.Printf(" a: %d\n", a)
|
||
fmt.Printf(" *p2: %d\n", *p2)
|
||
|
||
// nil 指针检查
|
||
fmt.Printf(" nil 指针检查:\n")
|
||
|
||
var nilPtr *int
|
||
fmt.Printf(" nilPtr: %v\n", nilPtr)
|
||
fmt.Printf(" nilPtr == nil: %t\n", nilPtr == nil)
|
||
|
||
// 安全的指针使用
|
||
if nilPtr != nil {
|
||
fmt.Printf(" *nilPtr: %d\n", *nilPtr)
|
||
} else {
|
||
fmt.Printf(" nilPtr 是 nil，不能解引用\n")
|
||
}
|
||
|
||
// 指针比较
|
||
fmt.Printf(" 指针比较:\n")
|
||
|
||
x, y := 1, 2
|
||
px, py := &x, &y
|
||
px2 := &x
|
||
|
||
fmt.Printf(" px == py: %t (指向不同变量)\n", px == py)
|
||
fmt.Printf(" px == px2: %t (指向同一变量)\n", px == px2)
|
||
fmt.Printf(" px == nil: %t\n", px == nil)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePointersWithFunctions 演示指针与函数
|
||
func demonstratePointersWithFunctions() {
|
||
fmt.Println("3. 指针与函数:")
|
||
|
||
// 值传递 vs 指针传递
|
||
fmt.Printf(" 值传递 vs 指针传递:\n")
|
||
|
||
x := 10
|
||
fmt.Printf(" 原始值: %d\n", x)
|
||
|
||
// 值传递
|
||
modifyByValue(x)
|
||
fmt.Printf(" 值传递后: %d (未改变)\n", x)
|
||
|
||
// 指针传递
|
||
modifyByPointer(&x)
|
||
fmt.Printf(" 指针传递后: %d (已改变)\n", x)
|
||
|
||
// 函数返回指针
|
||
fmt.Printf(" 函数返回指针:\n")
|
||
|
||
ptr := createInt(42)
|
||
fmt.Printf(" 返回的指针: %p\n", ptr)
|
||
fmt.Printf(" 指针指向的值: %d\n", *ptr)
|
||
|
||
// 多个返回值包含指针
|
||
value, valuePtr := createIntPair(100)
|
||
fmt.Printf(" 返回值: %d\n", value)
|
||
fmt.Printf(" 返回指针: %p, 值: %d\n", valuePtr, *valuePtr)
|
||
|
||
// 指针作为函数参数的优势
|
||
fmt.Printf(" 指针作为函数参数的优势:\n")
|
||
|
||
// 交换变量
|
||
a, b := 5, 10
|
||
fmt.Printf(" 交换前: a=%d, b=%d\n", a, b)
|
||
swap(&a, &b)
|
||
fmt.Printf(" 交换后: a=%d, b=%d\n", a, b)
|
||
|
||
// 避免大结构体拷贝
|
||
fmt.Printf(" 避免大结构体拷贝:\n")
|
||
|
||
person := Person{Name: "Alice", Age: 25, Email: "alice@example.com"}
|
||
fmt.Printf(" 修改前: %+v\n", person)
|
||
|
||
// 使用指针避免结构体拷贝
|
||
updatePersonByPointer(&person, 26)
|
||
fmt.Printf(" 指针修改后: %+v\n", person)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePointersWithStructs 演示指针与结构体
|
||
func demonstratePointersWithStructs() {
|
||
fmt.Println("4. 指针与结构体:")
|
||
|
||
// 结构体指针的创建
|
||
fmt.Printf(" 结构体指针的创建:\n")
|
||
|
||
// 方式1: 先创建结构体，再取地址
|
||
person1 := Person{Name: "Alice", Age: 25, Email: "alice@example.com"}
|
||
personPtr1 := &person1
|
||
fmt.Printf(" 方式1: %+v\n", *personPtr1)
|
||
|
||
// 方式2: 直接创建结构体指针
|
||
personPtr2 := &Person{Name: "Bob", Age: 30, Email: "bob@example.com"}
|
||
fmt.Printf(" 方式2: %+v\n", *personPtr2)
|
||
|
||
// 方式3: 使用 new 函数
|
||
personPtr3 := new(Person)
|
||
personPtr3.Name = "Charlie"
|
||
personPtr3.Age = 35
|
||
personPtr3.Email = "charlie@example.com"
|
||
fmt.Printf(" 方式3: %+v\n", *personPtr3)
|
||
|
||
// 结构体指针的字段访问
|
||
fmt.Printf(" 结构体指针的字段访问:\n")
|
||
|
||
// 方式1: 显式解引用
|
||
fmt.Printf(" (*personPtr1).Name: %s\n", (*personPtr1).Name)
|
||
|
||
// 方式2: 自动解引用（推荐）
|
||
fmt.Printf(" personPtr1.Name: %s\n", personPtr1.Name)
|
||
|
||
// 修改结构体字段
|
||
fmt.Printf(" 修改结构体字段:\n")
|
||
fmt.Printf(" 修改前: %s\n", personPtr1.Name)
|
||
personPtr1.Name = "Alice Smith"
|
||
fmt.Printf(" 修改后: %s\n", personPtr1.Name)
|
||
fmt.Printf(" 原结构体: %s\n", person1.Name) // 也被修改了
|
||
|
||
// 结构体指针切片
|
||
fmt.Printf(" 结构体指针切片:\n")
|
||
|
||
people := []*Person{
|
||
{Name: "David", Age: 28, Email: "david@example.com"},
|
||
{Name: "Eve", Age: 32, Email: "eve@example.com"},
|
||
{Name: "Frank", Age: 29, Email: "frank@example.com"},
|
||
}
|
||
|
||
fmt.Printf(" 人员列表:\n")
|
||
for i, person := range people {
|
||
fmt.Printf(" %d: %s (%d岁)\n", i+1, person.Name, person.Age)
|
||
}
|
||
|
||
// 修改切片中的结构体
|
||
people[0].Age = 29
|
||
fmt.Printf(" 修改后第一个人的年龄: %d\n", people[0].Age)
|
||
|
||
// 结构体指针映射
|
||
fmt.Printf(" 结构体指针映射:\n")
|
||
|
||
userMap := map[string]*Person{
|
||
"alice": {Name: "Alice", Age: 25, Email: "alice@example.com"},
|
||
"bob": {Name: "Bob", Age: 30, Email: "bob@example.com"},
|
||
}
|
||
|
||
if user, exists := userMap["alice"]; exists {
|
||
fmt.Printf(" 找到用户: %+v\n", *user)
|
||
user.Age = 26 // 修改映射中的结构体
|
||
fmt.Printf(" 修改后: %+v\n", *user)
|
||
}
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePointersWithArraysSlices 演示指针与数组/切片
|
||
func demonstratePointersWithArraysSlices() {
|
||
fmt.Println("5. 指针与数组/切片:")
|
||
|
||
// 数组指针
|
||
fmt.Printf(" 数组指针:\n")
|
||
|
||
arr := [5]int{1, 2, 3, 4, 5}
|
||
arrPtr := &arr
|
||
|
||
fmt.Printf(" 数组: %v\n", arr)
|
||
fmt.Printf(" 数组指针: %p\n", arrPtr)
|
||
fmt.Printf(" 通过指针访问: %v\n", *arrPtr)
|
||
|
||
// 修改数组元素
|
||
arrPtr[2] = 99 // 等同于 (*arrPtr)[2] = 99
|
||
fmt.Printf(" 修改后数组: %v\n", arr)
|
||
|
||
// 元素指针
|
||
fmt.Printf(" 元素指针:\n")
|
||
|
||
slice := []int{10, 20, 30, 40, 50}
|
||
fmt.Printf(" 切片: %v\n", slice)
|
||
|
||
// 获取元素指针
|
||
elemPtr := &slice[2]
|
||
fmt.Printf(" slice[2] 的地址: %p\n", elemPtr)
|
||
fmt.Printf(" slice[2] 的值: %d\n", *elemPtr)
|
||
|
||
// 通过元素指针修改
|
||
*elemPtr = 300
|
||
fmt.Printf(" 修改后切片: %v\n", slice)
|
||
|
||
// 指针切片
|
||
fmt.Printf(" 指针切片:\n")
|
||
|
||
var intPtrs []*int
|
||
for i := range slice {
|
||
intPtrs = append(intPtrs, &slice[i])
|
||
}
|
||
|
||
fmt.Printf(" 指针切片长度: %d\n", len(intPtrs))
|
||
fmt.Printf(" 第一个指针指向的值: %d\n", *intPtrs[0])
|
||
|
||
// 通过指针切片修改原切片
|
||
*intPtrs[1] = 200
|
||
fmt.Printf(" 修改后原切片: %v\n", slice)
|
||
|
||
// 数组指针 vs 指针数组
|
||
fmt.Printf(" 数组指针 vs 指针数组:\n")
|
||
|
||
// 数组指针：指向数组的指针
|
||
var arrayPtr *[3]int = &[3]int{1, 2, 3}
|
||
fmt.Printf(" 数组指针类型: %T\n", arrayPtr)
|
||
fmt.Printf(" 数组指针值: %v\n", *arrayPtr)
|
||
|
||
// 指针数组：元素是指针的数组
|
||
x, y, z := 1, 2, 3
|
||
var ptrArray [3]*int = [3]*int{&x, &y, &z}
|
||
fmt.Printf(" 指针数组类型: %T\n", ptrArray)
|
||
fmt.Printf(" 指针数组值: [%d, %d, %d]\n", *ptrArray[0], *ptrArray[1], *ptrArray[2])
|
||
|
||
fmt.Println()
|
||
}// demons
|
||
trateAdvancedPointerUsage 演示指针的高级用法
|
||
func demonstrateAdvancedPointerUsage() {
|
||
fmt.Println("6. 指针的高级用法:")
|
||
|
||
// 双重指针
|
||
fmt.Printf(" 双重指针:\n")
|
||
|
||
x := 42
|
||
ptr := &x
|
||
ptrPtr := &ptr
|
||
|
||
fmt.Printf(" x: %d\n", x)
|
||
fmt.Printf(" ptr: %p, *ptr: %d\n", ptr, *ptr)
|
||
fmt.Printf(" ptrPtr: %p, *ptrPtr: %p, **ptrPtr: %d\n", ptrPtr, *ptrPtr, **ptrPtr)
|
||
|
||
// 通过双重指针修改
|
||
**ptrPtr = 100
|
||
fmt.Printf(" **ptrPtr = 100 后, x: %d\n", x)
|
||
|
||
// 指针与接口
|
||
fmt.Printf(" 指针与接口:\n")
|
||
|
||
var shape Shape
|
||
|
||
// 值类型实现接口
|
||
circle := Circle{Radius: 5}
|
||
shape = circle
|
||
fmt.Printf(" 圆形面积: %.2f\n", shape.Area())
|
||
|
||
// 指针类型实现接口
|
||
rect := &Rectangle{Width: 4, Height: 3}
|
||
shape = rect
|
||
fmt.Printf(" 矩形面积: %.2f\n", shape.Area())
|
||
|
||
// 指针与方法集
|
||
fmt.Printf(" 指针与方法集:\n")
|
||
|
||
counter := Counter{Value: 0}
|
||
fmt.Printf(" 初始计数器: %+v\n", counter)
|
||
|
||
// 值类型调用指针接收者方法（自动取地址）
|
||
counter.Increment()
|
||
fmt.Printf(" 调用 Increment() 后: %+v\n", counter)
|
||
|
||
// 指针类型调用值接收者方法（自动解引用）
|
||
counterPtr := &Counter{Value: 10}
|
||
value := counterPtr.GetValue()
|
||
fmt.Printf(" 指针调用值方法: %d\n", value)
|
||
|
||
// unsafe 包的使用（谨慎使用）
|
||
fmt.Printf(" unsafe 包的使用:\n")
|
||
|
||
var num int64 = 0x1234567890ABCDEF
|
||
fmt.Printf(" 原始值: 0x%X\n", num)
|
||
|
||
// 获取指针
|
||
numPtr := unsafe.Pointer(&num)
|
||
|
||
// 将 int64 指针转换为 int32 指针（低32位）
|
||
lowPtr := (*int32)(numPtr)
|
||
fmt.Printf(" 低32位: 0x%X\n", *lowPtr)
|
||
|
||
// 获取高32位
|
||
highPtr := (*int32)(unsafe.Pointer(uintptr(numPtr) + 4))
|
||
fmt.Printf(" 高32位: 0x%X\n", *highPtr)
|
||
|
||
// 指针大小
|
||
fmt.Printf(" 指针大小:\n")
|
||
fmt.Printf(" 指针大小: %d 字节\n", unsafe.Sizeof(ptr))
|
||
fmt.Printf(" uintptr 大小: %d 字节\n", unsafe.Sizeof(uintptr(0)))
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePracticalApplications 演示指针的实际应用
|
||
func demonstratePracticalApplications() {
|
||
fmt.Println("7. 指针的实际应用:")
|
||
|
||
// 应用1: 链表实现
|
||
fmt.Printf(" 应用1 - 链表实现:\n")
|
||
|
||
list := &LinkedList{}
|
||
|
||
// 添加节点
|
||
list.Add(1)
|
||
list.Add(2)
|
||
list.Add(3)
|
||
|
||
fmt.Printf(" 链表内容: ")
|
||
list.Print()
|
||
|
||
// 查找节点
|
||
if list.Contains(2) {
|
||
fmt.Printf(" 链表包含值 2\n")
|
||
}
|
||
|
||
// 删除节点
|
||
list.Remove(2)
|
||
fmt.Printf(" 删除 2 后: ")
|
||
list.Print()
|
||
|
||
// 应用2: 树结构
|
||
fmt.Printf(" 应用2 - 二叉树:\n")
|
||
|
||
tree := &BinaryTree{}
|
||
|
||
// 插入节点
|
||
tree.Insert(5)
|
||
tree.Insert(3)
|
||
tree.Insert(7)
|
||
tree.Insert(1)
|
||
tree.Insert(9)
|
||
|
||
fmt.Printf(" 中序遍历: ")
|
||
tree.InorderTraversal()
|
||
fmt.Printf("\n")
|
||
|
||
// 查找节点
|
||
if tree.Search(7) {
|
||
fmt.Printf(" 树中包含值 7\n")
|
||
}
|
||
|
||
// 应用3: 缓存系统
|
||
fmt.Printf(" 应用3 - LRU 缓存:\n")
|
||
|
||
cache := NewLRUCache(3)
|
||
|
||
// 添加缓存项
|
||
cache.Put("a", 1)
|
||
cache.Put("b", 2)
|
||
cache.Put("c", 3)
|
||
|
||
fmt.Printf(" 缓存状态: ")
|
||
cache.Print()
|
||
|
||
// 访问缓存项
|
||
if value, found := cache.Get("b"); found {
|
||
fmt.Printf(" 获取 'b': %d\n", value)
|
||
}
|
||
|
||
// 添加新项（会淘汰最久未使用的）
|
||
cache.Put("d", 4)
|
||
fmt.Printf(" 添加 'd' 后: ")
|
||
cache.Print()
|
||
|
||
// 应用4: 对象池
|
||
fmt.Printf(" 应用4 - 对象池:\n")
|
||
|
||
pool := NewObjectPool()
|
||
|
||
// 获取对象
|
||
obj1 := pool.Get()
|
||
obj2 := pool.Get()
|
||
|
||
fmt.Printf(" 获取对象1: %p\n", obj1)
|
||
fmt.Printf(" 获取对象2: %p\n", obj2)
|
||
|
||
// 使用对象
|
||
obj1.Data = "Hello"
|
||
obj2.Data = "World"
|
||
|
||
fmt.Printf(" 对象1数据: %s\n", obj1.Data)
|
||
fmt.Printf(" 对象2数据: %s\n", obj2.Data)
|
||
|
||
// 归还对象
|
||
pool.Put(obj1)
|
||
pool.Put(obj2)
|
||
|
||
// 再次获取（可能复用之前的对象）
|
||
obj3 := pool.Get()
|
||
fmt.Printf(" 再次获取对象: %p (数据: %s)\n", obj3, obj3.Data)
|
||
|
||
// 应用5: 回调函数
|
||
fmt.Printf(" 应用5 - 回调函数:\n")
|
||
|
||
processor := &DataProcessor{}
|
||
|
||
// 设置回调函数
|
||
processor.SetCallback(func(data string) {
|
||
fmt.Printf(" 处理数据: %s\n", data)
|
||
})
|
||
|
||
// 处理数据
|
||
processor.Process("Hello, World!")
|
||
|
||
// 应用6: 观察者模式
|
||
fmt.Printf(" 应用6 - 观察者模式:\n")
|
||
|
||
subject := &Subject{}
|
||
|
||
// 添加观察者
|
||
observer1 := &Observer{Name: "Observer1"}
|
||
observer2 := &Observer{Name: "Observer2"}
|
||
|
||
subject.AddObserver(observer1)
|
||
subject.AddObserver(observer2)
|
||
|
||
// 通知观察者
|
||
subject.NotifyObservers("重要消息")
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// ========== 类型定义 ==========
|
||
|
||
// 基本结构体
|
||
type Person struct {
|
||
Name string
|
||
Age int
|
||
Email string
|
||
}
|
||
|
||
// 几何图形接口
|
||
type Shape interface {
|
||
Area() float64
|
||
}
|
||
|
||
// 圆形
|
||
type Circle struct {
|
||
Radius float64
|
||
}
|
||
|
||
func (c Circle) Area() float64 {
|
||
return 3.14159 * c.Radius * c.Radius
|
||
}
|
||
|
||
// 矩形
|
||
type Rectangle struct {
|
||
Width float64
|
||
Height float64
|
||
}
|
||
|
||
func (r Rectangle) Area() float64 {
|
||
return r.Width * r.Height
|
||
}
|
||
|
||
// 计数器
|
||
type Counter struct {
|
||
Value int
|
||
}
|
||
|
||
func (c *Counter) Increment() {
|
||
c.Value++
|
||
}
|
||
|
||
func (c Counter) GetValue() int {
|
||
return c.Value
|
||
}
|
||
|
||
// 链表节点
|
||
type ListNode struct {
|
||
Value int
|
||
Next *ListNode
|
||
}
|
||
|
||
// 链表
|
||
type LinkedList struct {
|
||
Head *ListNode
|
||
}
|
||
|
||
func (l *LinkedList) Add(value int) {
|
||
newNode := &ListNode{Value: value}
|
||
if l.Head == nil {
|
||
l.Head = newNode
|
||
} else {
|
||
current := l.Head
|
||
for current.Next != nil {
|
||
current = current.Next
|
||
}
|
||
current.Next = newNode
|
||
}
|
||
}
|
||
|
||
func (l *LinkedList) Contains(value int) bool {
|
||
current := l.Head
|
||
for current != nil {
|
||
if current.Value == value {
|
||
return true
|
||
}
|
||
current = current.Next
|
||
}
|
||
return false
|
||
}
|
||
|
||
func (l *LinkedList) Remove(value int) {
|
||
if l.Head == nil {
|
||
return
|
||
}
|
||
|
||
if l.Head.Value == value {
|
||
l.Head = l.Head.Next
|
||
return
|
||
}
|
||
|
||
current := l.Head
|
||
for current.Next != nil {
|
||
if current.Next.Value == value {
|
||
current.Next = current.Next.Next
|
||
return
|
||
}
|
||
current = current.Next
|
||
}
|
||
}
|
||
|
||
func (l *LinkedList) Print() {
|
||
current := l.Head
|
||
for current != nil {
|
||
fmt.Printf("%d ", current.Value)
|
||
current = current.Next
|
||
}
|
||
fmt.Printf("\n")
|
||
}
|
||
|
||
// 二叉树节点
|
||
type TreeNode struct {
|
||
Value int
|
||
Left *TreeNode
|
||
Right *TreeNode
|
||
}
|
||
|
||
// 二叉树
|
||
type BinaryTree struct {
|
||
Root *TreeNode
|
||
}
|
||
|
||
func (t *BinaryTree) Insert(value int) {
|
||
t.Root = t.insertNode(t.Root, value)
|
||
}
|
||
|
||
func (t *BinaryTree) insertNode(node *TreeNode, value int) *TreeNode {
|
||
if node == nil {
|
||
return &TreeNode{Value: value}
|
||
}
|
||
|
||
if value < node.Value {
|
||
node.Left = t.insertNode(node.Left, value)
|
||
} else {
|
||
node.Right = t.insertNode(node.Right, value)
|
||
}
|
||
|
||
return node
|
||
}
|
||
|
||
func (t *BinaryTree) Search(value int) bool {
|
||
return t.searchNode(t.Root, value)
|
||
}
|
||
|
||
func (t *BinaryTree) searchNode(node *TreeNode, value int) bool {
|
||
if node == nil {
|
||
return false
|
||
}
|
||
|
||
if value == node.Value {
|
||
return true
|
||
} else if value < node.Value {
|
||
return t.searchNode(node.Left, value)
|
||
} else {
|
||
return t.searchNode(node.Right, value)
|
||
}
|
||
}
|
||
|
||
func (t *BinaryTree) InorderTraversal() {
|
||
t.inorderNode(t.Root)
|
||
}
|
||
|
||
func (t *BinaryTree) inorderNode(node *TreeNode) {
|
||
if node != nil {
|
||
t.inorderNode(node.Left)
|
||
fmt.Printf("%d ", node.Value)
|
||
t.inorderNode(node.Right)
|
||
}
|
||
}
|
||
|
||
// LRU 缓存节点
|
||
type CacheNode struct {
|
||
Key string
|
||
Value int
|
||
Prev *CacheNode
|
||
Next *CacheNode
|
||
}
|
||
|
||
// LRU 缓存
|
||
type LRUCache struct {
|
||
Capacity int
|
||
Cache map[string]*CacheNode
|
||
Head *CacheNode
|
||
Tail *CacheNode
|
||
}
|
||
|
||
func NewLRUCache(capacity int) *LRUCache {
|
||
head := &CacheNode{}
|
||
tail := &CacheNode{}
|
||
head.Next = tail
|
||
tail.Prev = head
|
||
|
||
return &LRUCache{
|
||
Capacity: capacity,
|
||
Cache: make(map[string]*CacheNode),
|
||
Head: head,
|
||
Tail: tail,
|
||
}
|
||
}
|
||
|
||
func (c *LRUCache) Get(key string) (int, bool) {
|
||
if node, exists := c.Cache[key]; exists {
|
||
c.moveToHead(node)
|
||
return node.Value, true
|
||
}
|
||
return 0, false
|
||
}
|
||
|
||
func (c *LRUCache) Put(key string, value int) {
|
||
if node, exists := c.Cache[key]; exists {
|
||
node.Value = value
|
||
c.moveToHead(node)
|
||
} else {
|
||
newNode := &CacheNode{Key: key, Value: value}
|
||
c.Cache[key] = newNode
|
||
c.addToHead(newNode)
|
||
|
||
if len(c.Cache) > c.Capacity {
|
||
tail := c.removeTail()
|
||
delete(c.Cache, tail.Key)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (c *LRUCache) addToHead(node *CacheNode) {
|
||
node.Prev = c.Head
|
||
node.Next = c.Head.Next
|
||
c.Head.Next.Prev = node
|
||
c.Head.Next = node
|
||
}
|
||
|
||
func (c *LRUCache) removeNode(node *CacheNode) {
|
||
node.Prev.Next = node.Next
|
||
node.Next.Prev = node.Prev
|
||
}
|
||
|
||
func (c *LRUCache) moveToHead(node *CacheNode) {
|
||
c.removeNode(node)
|
||
c.addToHead(node)
|
||
}
|
||
|
||
func (c *LRUCache) removeTail() *CacheNode {
|
||
lastNode := c.Tail.Prev
|
||
c.removeNode(lastNode)
|
||
return lastNode
|
||
}
|
||
|
||
func (c *LRUCache) Print() {
|
||
current := c.Head.Next
|
||
for current != c.Tail {
|
||
fmt.Printf("(%s:%d) ", current.Key, current.Value)
|
||
current = current.Next
|
||
}
|
||
fmt.Printf("\n")
|
||
}
|
||
|
||
// 对象池
|
||
type PoolObject struct {
|
||
Data string
|
||
}
|
||
|
||
type ObjectPool struct {
|
||
pool []*PoolObject
|
||
}
|
||
|
||
func NewObjectPool() *ObjectPool {
|
||
return &ObjectPool{
|
||
pool: make([]*PoolObject, 0),
|
||
}
|
||
}
|
||
|
||
func (p *ObjectPool) Get() *PoolObject {
|
||
if len(p.pool) > 0 {
|
||
obj := p.pool[len(p.pool)-1]
|
||
p.pool = p.pool[:len(p.pool)-1]
|
||
return obj
|
||
}
|
||
return &PoolObject{}
|
||
}
|
||
|
||
func (p *ObjectPool) Put(obj *PoolObject) {
|
||
obj.Data = "" // 重置对象
|
||
p.pool = append(p.pool, obj)
|
||
}
|
||
|
||
// 数据处理器
|
||
type DataProcessor struct {
|
||
callback func(string)
|
||
}
|
||
|
||
func (d *DataProcessor) SetCallback(callback func(string)) {
|
||
d.callback = callback
|
||
}
|
||
|
||
func (d *DataProcessor) Process(data string) {
|
||
if d.callback != nil {
|
||
d.callback(data)
|
||
}
|
||
}
|
||
|
||
// 观察者模式
|
||
type Observer struct {
|
||
Name string
|
||
}
|
||
|
||
func (o *Observer) Update(message string) {
|
||
fmt.Printf(" %s 收到消息: %s\n", o.Name, message)
|
||
}
|
||
|
||
type Subject struct {
|
||
observers []*Observer
|
||
}
|
||
|
||
func (s *Subject) AddObserver(observer *Observer) {
|
||
s.observers = append(s.observers, observer)
|
||
}
|
||
|
||
func (s *Subject) NotifyObservers(message string) {
|
||
for _, observer := range s.observers {
|
||
observer.Update(message)
|
||
}
|
||
}
|
||
|
||
// ========== 辅助函数 ==========
|
||
|
||
// 值传递函数
|
||
func modifyByValue(x int) {
|
||
x = 999
|
||
fmt.Printf(" 函数内部: %d\n", x)
|
||
}
|
||
|
||
// 指针传递函数
|
||
func modifyByPointer(x *int) {
|
||
*x = 888
|
||
fmt.Printf(" 函数内部: %d\n", *x)
|
||
}
|
||
|
||
// 返回指针的函数
|
||
func createInt(value int) *int {
|
||
x := value // 局部变量
|
||
return &x // 返回局部变量的地址（Go 会自动分配到堆上）
|
||
}
|
||
|
||
// 返回值和指针
|
||
func createIntPair(value int) (int, *int) {
|
||
x := value
|
||
return x, &x
|
||
}
|
||
|
||
// 交换函数
|
||
func swap(a, b *int) {
|
||
*a, *b = *b, *a
|
||
}
|
||
|
||
// 更新结构体
|
||
func updatePersonByPointer(p *Person, newAge int) {
|
||
p.Age = newAge
|
||
}
|
||
|
||
/*
|
||
运行这个程序：
|
||
go run 05-pointers.go
|
||
|
||
学习要点：
|
||
1. 指针存储变量的内存地址，通过地址间接访问变量
|
||
2. 使用 & 获取地址，使用 * 解引用指针
|
||
3. 指针的零值是 nil，使用前要检查
|
||
4. 指针传参可以避免大对象拷贝，允许函数修改原变量
|
||
5. Go 的指针是类型安全的，不支持指针运算
|
||
|
||
指针的特性：
|
||
1. 类型安全：不同类型的指针不能相互赋值
|
||
2. 自动管理：垃圾回收器自动管理内存
|
||
3. 无指针运算：不支持 C 风格的指针运算
|
||
4. 自动解引用：结构体指针可以直接访问字段
|
||
5. 方法调用：自动在值和指针间转换
|
||
|
||
指针的用途：
|
||
1. 避免大对象拷贝
|
||
2. 允许函数修改参数
|
||
3. 实现数据结构（链表、树等）
|
||
4. 共享数据
|
||
5. 可选值表示
|
||
|
||
指针与函数：
|
||
1. 值传递：传递变量的拷贝
|
||
2. 指针传递：传递变量的地址
|
||
3. 返回指针：可以返回局部变量的地址
|
||
4. 方法接收者：值接收者 vs 指针接收者
|
||
|
||
最佳实践：
|
||
1. 使用前检查指针是否为 nil
|
||
2. 大结构体使用指针传递
|
||
3. 需要修改参数时使用指针
|
||
4. 合理使用指针避免内存泄漏
|
||
5. 优先使用值类型，必要时使用指针
|
||
|
||
常见应用场景：
|
||
1. 数据结构实现
|
||
2. 对象池和缓存
|
||
3. 回调函数
|
||
4. 观察者模式
|
||
5. 链式数据结构
|
||
6. 可选参数
|
||
|
||
注意事项：
|
||
1. nil 指针解引用会 panic
|
||
2. 指针比较比较的是地址
|
||
3. 指针可能导致内存泄漏
|
||
4. 避免返回栈变量的指针（Go 会自动处理）
|
||
5. 理解值接收者和指针接收者的区别
|
||
|
||
unsafe 包：
|
||
1. 提供底层内存操作
|
||
2. 绕过类型安全检查
|
||
3. 谨慎使用，可能破坏内存安全
|
||
4. 主要用于系统编程和性能优化
|
||
*/ |