如何用反射实现Golang的泛型容器 演示运行时类型安全的集合操作

package main

import (
    "fmt"
    "reflect"
)

// GenericContainer 通用容器
type GenericContainer struct {
    elementType reflect.Type // 元素类型
    elements    []reflect.Value // 元素集合
}

// NewGenericContainer 创建一个新的通用容器
func NewGenericContainer(elementType reflect.Type) *GenericContainer {
    return &GenericContainer{
        elementType: elementType,
        elements:    make([]reflect.Value, 0),
    }
}

// Add 添加元素到容器
func (gc *GenericContainer) Add(element interface{}) error {
    val := reflect.ValueOf(element)
    if val.Type() != gc.elementType {
        return fmt.Errorf("类型不匹配: expected %s, got %s", gc.elementType, val.Type())
    }
    gc.elements = append(gc.elements, val)
    return nil
}

// Get 获取指定索引的元素
func (gc *GenericContainer) Get(index int) (interface{}, error) {
    if index < 0 || index >= len(gc.elements) {
        return nil, fmt.Errorf("索引越界")
    }
    return gc.elements[index].Interface(), nil
}

// Size 获取容器大小
func (gc *GenericContainer) Size() int {
    return len(gc.elements)
}

func main() {
    // 创建一个存储 int 类型元素的容器
    intContainer := NewGenericContainer(reflect.TypeOf(0))

    // 添加元素
    err := intContainer.Add(10)
    if err != nil {
        fmt.Println(err)
    }
    err = intContainer.Add(20)
    if err != nil {
        fmt.Println(err)
    }

    // 尝试添加错误类型的元素
    err = intContainer.Add("hello")
    if err != nil {
        fmt.Println(err) // 输出：类型不匹配: expected int, got string
    }

    // 获取元素
    val, err := intContainer.Get(0)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(val) // 输出：10

    // 创建一个存储 string 类型元素的容器
    stringContainer := NewGenericContainer(reflect.TypeOf(""))
    stringContainer.Add("world")
    strVal, _ := stringContainer.Get(0)
    fmt.Println(strVal) // 输出：world
}

package main

import (
    "fmt"
    "reflect"
)

// Person 结构体
type Person struct {
    Name string
    Age  int
}

func main() {
    // 创建一个存储 Person 类型元素的容器
    personContainer := NewGenericContainer(reflect.TypeOf(Person{}))

    // 创建 Person 实例
    p1 := Person{Name: "Alice", Age: 30}
    p2 := Person{Name: "Bob", Age: 25}

    // 添加 Person 实例到容器
    err := personContainer.Add(p1)
    if err != nil {
        fmt.Println(err)
    }
    err = personContainer.Add(p2)
    if err != nil {
        fmt.Println(err)
    }

    // 获取元素
    val, err := personContainer.Get(0)
    if err != nil {
        fmt.Println(err)
    }
    person, ok := val.(Person) // 类型断言
    if !ok {
        fmt.Println("类型断言失败")
    } else {
        fmt.Printf("Name: %s, Age: %d\n", person.Name, person.Age) // 输出：Name: Alice, Age: 30
    }
}

package main

import (
    "fmt"
    "reflect"
    "sync"
)

// ConcurrentGenericContainer 并发安全的通用容器
type ConcurrentGenericContainer struct {
    elementType reflect.Type
    elements    []reflect.Value
    mu          sync.Mutex // 互斥锁
}

// NewConcurrentGenericContainer 创建一个新的并发安全通用容器
func NewConcurrentGenericContainer(elementType reflect.Type) *ConcurrentGenericContainer {
    return &ConcurrentGenericContainer{
        elementType: elementType,
        elements:    make([]reflect.Value, 0),
        mu:          sync.Mutex{},
    }
}

// Add 添加元素到容器
func (gc *ConcurrentGenericContainer) Add(element interface{}) error {
    gc.mu.Lock()
    defer gc.mu.Unlock()

    val := reflect.ValueOf(element)
    if val.Type() != gc.elementType {
        return fmt.Errorf("类型不匹配: expected %s, got %s", gc.elementType, val.Type())
    }
    gc.elements = append(gc.elements, val)
    return nil
}

// Get 获取指定索引的元素
func (gc *ConcurrentGenericContainer) Get(index int) (interface{}, error) {
    gc.mu.Lock()
    defer gc.mu.Unlock()

    if index < 0 || index >= len(gc.elements) {
        return nil, fmt.Errorf("索引越界")
    }
    return gc.elements[index].Interface(), nil
}

// Size 获取容器大小
func (gc *ConcurrentGenericContainer) Size() int {
    gc.mu.Lock()
    defer gc.mu.Unlock()
    return len(gc.elements)
}

func main() {
    // 创建一个存储 int 类型元素的并发安全容器
    intContainer := NewConcurrentGenericContainer(reflect.TypeOf(0))

    // 并发添加元素
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            err := intContainer.Add(i)
            if err != nil {
                fmt.Println(err)
            }
        }(i)
    }
    wg.Wait()

    fmt.Println("Container size:", intContainer.Size()) // 输出：Container size: 100
}