Go 语言中将值指针转换为切片：原理、实践与风险

struct SliceHeader {
  Data uintptr // 指向底层数组的指针
  Len  int     // 切片的长度
  Cap  int     // 切片的容量
}

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    var myByte uint8
    reader := strings.NewReader("Hello")

    // 错误示例：不能直接将变量地址传递给 Read
    // n, err := reader.Read(&myByte) // 编译错误：cannot use &myByte (type *uint8) as type []byte in argument to reader.Read
    // fmt.Println(n, err, myByte)
}

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    var myByte uint8
    reader := strings.NewReader("Hello")

    // 创建一个长度为1的字节切片作为缓冲区
    buf := make([]byte, 1)

    // 读取一个字节到缓冲区
    n, err := reader.Read(buf)
    if err != nil && err != io.EOF {
        fmt.Printf("Error reading: %v\n", err)
        return
    }

    // 如果成功读取到字节，则将其赋值给 myByte
    if n > 0 {
        myByte = buf[0]
    }

    fmt.Printf("Read byte: %c (uint8: %d)\n", myByte, myByte) // Output: Read byte: H (uint8: 72)

    // 再次读取
    n, err = reader.Read(buf)
    if err != nil && err != io.EOF {
        fmt.Printf("Error reading: %v\n", err)
        return
    }
    if n > 0 {
        myByte = buf[0]
    }
    fmt.Printf("Read byte: %c (uint8: %d)\n", myByte, myByte) // Output: Read byte: e (uint8: 101)
}

package main

import "fmt"

func main() {
    a := uint8(42)
    fmt.Printf("Original variable a: %d\n", a)

    // 创建一个包含变量a值的切片
    sliceFromValue := []uint8{a}
    fmt.Printf("Slice from value: %#v\n", sliceFromValue) // Output: Slice from value: []uint8{0x2a}

    // 注意：sliceFromValue 是 a 的一个副本，修改 sliceFromValue 不会影响 a
    sliceFromValue[0] = 99
    fmt.Printf("After modifying sliceFromValue[0], a: %d, sliceFromValue: %#v\n", a, sliceFromValue)
    // Output: After modifying sliceFromValue[0], a: 42, sliceFromValue: []uint8{0x63}
}

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a uint8 = 42
    fmt.Printf("Original variable a: %d\n", a) // Output: Original variable a: 42

    // 1. 获取变量 a 的指针
    ptrA := &a

    // 2. 将 *uint8 转换为 unsafe.Pointer
    unsafePtr := unsafe.Pointer(ptrA)

    // 3. 将 unsafe.Pointer 转换为 *[1]uint8 类型指针
    // 这表示我们现在将该内存区域视为一个长度为1的uint8数组
    arrayPtr := (*[1]uint8)(unsafePtr)

    // 4. 对 *[1]uint8 类型的指针进行切片操作，得到 []uint8
    // arrayPtr[:] 会创建一个切片，其底层数组就是变量 a 的内存
    sliceFromUnsafe := arrayPtr[:]

    fmt.Printf("Slice from unsafe: %#v\n", sliceFromUnsafe) // Output: Slice from unsafe: []uint8{0x2a}

    // 验证：修改切片会影响原始变量 a
    sliceFromUnsafe[0] = 99
    fmt.Printf("After modifying sliceFromUnsafe[0], a: %d, sliceFromUnsafe: %#v\n", a, sliceFromUnsafe)
    // Output: After modifying sliceFromUnsafe[0], a: 99, sliceFromUnsafe: []uint8{0x63}
}