Golang指针存储地址技巧解析

哈喽！今天心血来潮给大家带来了《Golang 指针存储地址方法详解》，想必大家应该对Golang都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习Golang，千万别错过这篇文章~希望能帮助到你！

在 Golang 中，有时我们需要存储指针指向的内存地址，例如创建一个映射，将对象的地址与其分配时间关联起来。本文将探讨如何获取 new() 函数返回的地址，并将其存储在 map 中。我们将讨论使用 unsafe 包和 reflect 包来实现这一目标，并权衡各自的优缺点。

使用 unsafe 包

unsafe 包提供了一种直接访问内存的方式，允许我们将指针转换为 uintptr 类型，从而可以将其用作 map 的键。

package main

import (
    "fmt"
    "time"
    "unsafe"
)

type T struct {
    a, b int
}

func main() {
    var t int64 = time.Now().UnixNano()
    memmap := make(map[uintptr]int64)
    fmt.Printf("%d\n", t)
    var ptr *T = new(T)
    ptr.a = 1
    ptr.b = 2
    fmt.Printf("%d %d %p %T\n", ptr.a, ptr.b, ptr, ptr)

    // 将指针转换为 uintptr
    addr := uintptr(unsafe.Pointer(ptr))
    memmap[addr] = t
    fmt.Printf("Address stored in map: %x\n", addr)

    // 从 map 中检索地址
    retrievedAddr := uintptr(unsafe.Pointer(ptr))
    if val, ok := memmap[retrievedAddr]; ok {
        fmt.Printf("Value associated with address: %d\n", val)
    }

}

注意事项：

• unsafe 包的使用需要谨慎，因为它绕过了 Golang 的类型安全机制。
• 直接操作内存可能导致程序崩溃或其他不可预测的行为。
• uintptr 类型的大小取决于底层架构（32 位或 64 位）。
• 垃圾回收器可能会移动对象，导致存储的地址失效。

使用 reflect 包

reflect 包提供了运行时反射的能力，允许我们检查和操作变量的类型和值。虽然 reflect 包本身不直接提供将指针转换为地址的功能，但可以结合 unsafe 包来实现。

package main

import (
    "fmt"
    "reflect"
    "time"
    "unsafe"
)

type T struct {
    a, b int
}

func main() {
    var t int64 = time.Now().UnixNano()
    memmap := make(map[uintptr]int64)
    fmt.Printf("%d\n", t)
    var ptr *T = new(T)
    ptr.a = 1
    ptr.b = 2
    fmt.Printf("%d %d %p %T\n", ptr.a, ptr.b, ptr, ptr)

    // 使用 reflect.ValueOf 获取指针的值
    value := reflect.ValueOf(ptr)

    // 使用 unsafe.Pointer 将 reflect.Value 转换为 unsafe.Pointer
    unsafePtr := unsafe.Pointer(value.Pointer())

    // 将 unsafe.Pointer 转换为 uintptr
    addr := uintptr(unsafePtr)
    memmap[addr] = t
    fmt.Printf("Address stored in map: %x\n", addr)

    // 从 map 中检索地址
    retrievedAddr := uintptr(unsafe.Pointer(value.Pointer()))
    if val, ok := memmap[retrievedAddr]; ok {
        fmt.Printf("Value associated with address: %d\n", val)
    }

}

注意事项：

• 与直接使用 unsafe 包相比，使用 reflect 包可以提供更强的类型安全性。
• reflect 包的性能开销比直接使用 unsafe 包要高。

更好的选择：使用类型和地址的元组

由于单独使用地址值存在风险，更好的做法是将类型信息与地址一起存储。这样可以避免类型安全问题，并提高程序的健壮性。

package main

import (
    "fmt"
    "time"
)

type T struct {
    a, b int
}

type AddressKey struct {
    Type string
    Addr uintptr
}

func main() {
    var t int64 = time.Now().UnixNano()
    memmap := make(map[AddressKey]int64)
    fmt.Printf("%d\n", t)
    var ptr *T = new(T)
    ptr.a = 1
    ptr.b = 2
    fmt.Printf("%d %d %p %T\n", ptr.a, ptr.b, ptr, ptr)

    // 创建 AddressKey
    key := AddressKey{
        Type: fmt.Sprintf("%T", ptr),
        Addr: uintptr(uintptr(unsafe.Pointer(ptr))), // or use reflect as in previous example
    }
    memmap[key] = t
    fmt.Printf("Address stored in map: %x\n", key.Addr)

    // 从 map 中检索地址
    retrievedKey := AddressKey{
        Type: fmt.Sprintf("%T", ptr),
        Addr: uintptr(uintptr(unsafe.Pointer(ptr))), // or use reflect as in previous example
    }
    if val, ok := memmap[retrievedKey]; ok {
        fmt.Printf("Value associated with address: %d\n", val)
    }

}

总结：

存储指针指向的地址在某些情况下可能很有用，但需要谨慎处理。unsafe 包提供了直接访问内存的方式，但存在安全风险。reflect 包可以提供更强的类型安全性，但性能开销较高。更好的做法是将类型信息与地址一起存储，以提高程序的健壮性。在选择方法时，请权衡安全性和性能，并根据实际需求做出决策。

好了，本文到此结束，带大家了解了《Golang指针存储地址技巧解析》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！