Go语言中&运算符：理解变量地址与指针传递

package main

import "fmt"

func main() {
    var num int = 10              // 声明并初始化一个int类型变量num
    var ptr *int                  // 声明一个指向int类型的指针变量ptr

    ptr = &num                    // 使用&运算符获取num的内存地址，并赋值给ptr

    fmt.Printf("num 的值: %d\n", num)        // 输出: num 的值: 10
    fmt.Printf("num 的内存地址: %p\n", &num)    // 输出: num 的内存地址: 0xc0000140a0 (示例地址)
    fmt.Printf("ptr 的值 (num 的地址): %p\n", ptr) // 输出: ptr 的值 (num 的地址): 0xc0000140a0
    fmt.Printf("ptr 指向的值: %d\n", *ptr)     // 使用*运算符（解引用）获取指针指向的值，输出: ptr 指向的值: 10

    // 通过指针修改原始变量的值
    *ptr = 20
    fmt.Printf("修改后 num 的值: %d\n", num) // 输出: 修改后 num 的值: 20
}

package main

import "fmt"

// modifyValue 接收一个int值，对其修改不影响原始变量
func modifyValue(val int) {
    val = 100
    fmt.Printf("函数内部 modifyValue: val = %d\n", val)
}

// modifyPointer 接收一个*int指针，可以修改原始变量的值
func modifyPointer(ptr *int) {
    *ptr = 200 // 解引用指针并修改其指向的值
    fmt.Printf("函数内部 modifyPointer: *ptr = %d\n", *ptr)
}

func main() {
    a := 10
    fmt.Printf("调用前 a = %d\n", a) // 输出: 调用前 a = 10

    modifyValue(a)
    fmt.Printf("调用 modifyValue 后 a = %d\n", a) // 输出: 调用 modifyValue 后 a = 10 (未改变)

    modifyPointer(&a) // 传递a的地址
    fmt.Printf("调用 modifyPointer 后 a = %d\n", a) // 输出: 调用 modifyPointer 后 a = 200 (已改变)
}

var t txn
t.c = c
err := c.read(&t.req)

package main

import "fmt"

// Request 代表一个请求结构体
type Request struct {
    ID     string
    Data   []byte
    Status string
}

// Connection 代表一个连接对象
type Connection struct {
    // ... 可能包含网络连接、缓冲区等
}

// txn 代表一个事务结构体，其中包含一个Request字段
type txn struct {
    req Request // req 是一个Request类型的值
    // ... 其他事务相关字段
}

// read 方法从连接中读取数据并填充到传入的Request指针所指向的结构体中
func (conn *Connection) read(req *Request) error {
    fmt.Println("执行 Connection.read 方法...")
    // 模拟从连接中读取数据并填充到req指向的Request结构体中
    req.ID = "REQ-001"
    req.Data = []byte("Hello Go Pointers!")
    req.Status = "Processed"
    return nil
}

func main() {
    var t txn           // 声明一个txn类型的变量t
    var c Connection    // 声明一个Connection类型的变量c

    // 假设t.c已经被初始化，这里简化为直接使用c
    // t.c = c

    fmt.Printf("调用前 t.req: %+v\n", t.req) // 输出: 调用前 t.req: {ID: Data:[] Status:}

    // 调用c.read方法，并传递t.req字段的地址
    err := c.read(&t.req)

    if err != nil {
        fmt.Printf("读取错误: %v\n", err)
    } else {
        fmt.Printf("调用后 t.req: %+v\n", t.req) // 输出: 调用后 t.req: {ID:REQ-001 Data:[72 101 108 108 111 32 71 111 32 80 111 105 110 116 101 114 115 33] Status:Processed}
    }
}