Golang中如何优雅地创建包含混合元素的结构体

在Go语言中，可以通过接口（interface）和类型断言（type assertion）来优雅地创建包含混合元素的结构体，无需使用不安全指针。以下是一个示例：

package main

import (
	"fmt"
)

// 定义接口
type Element interface {
	Display()
}

// 定义不同类型实现接口
type Integer struct {
	Value int
}

func (i Integer) Display() {
	fmt.Printf("Integer: %d\n", i.Value)
}

type String struct {
	Value string
}

func (s String) Display() {
	fmt.Printf("String: %s\n", s.Value)
}

type Float struct {
	Value float64
}

func (f Float) Display() {
	fmt.Printf("Float: %.2f\n", f.Value)
}

// 包含混合元素的结构体
type Container struct {
	Elements []Element
}

func main() {
	// 创建包含不同类型元素的容器
	container := Container{
		Elements: []Element{
			Integer{Value: 42},
			String{Value: "Hello"},
			Float{Value: 3.14},
			Integer{Value: 100},
		},
	}

	// 遍历并显示所有元素
	for _, elem := range container.Elements {
		elem.Display()
	}

	// 类型断言示例
	for _, elem := range container.Elements {
		switch v := elem.(type) {
		case Integer:
			fmt.Printf("Processing Integer: %d\n", v.Value)
		case String:
			fmt.Printf("Processing String: %s\n", v.Value)
		case Float:
			fmt.Printf("Processing Float: %.2f\n", v.Value)
		}
	}
}

输出：

Integer: 42
String: Hello
Float: 3.14
Integer: 100
Processing Integer: 42
Processing String: Hello
Processing Float: 3.14
Processing Integer: 100

如果需要更紧凑的变体类型，可以使用带标签的联合结构：

package main

import (
	"fmt"
)

type Variant struct {
	Type  string
	Value interface{}
}

func main() {
	variants := []Variant{
		{"int", 42},
		{"string", "hello"},
		{"float64", 3.14},
		{"bool", true},
	}

	for _, v := range variants {
		switch v.Type {
		case "int":
			fmt.Printf("Integer: %d\n", v.Value.(int))
		case "string":
			fmt.Printf("String: %s\n", v.Value.(string))
		case "float64":
			fmt.Printf("Float: %.2f\n", v.Value.(float64))
		case "bool":
			fmt.Printf("Boolean: %v\n", v.Value.(bool))
		}
	}
}

对于需要类型安全的场景，可以使用泛型（Go 1.18+）：

package main

import (
	"fmt"
)

type Variant[T any] struct {
	value T
}

func NewVariant[T any](value T) Variant[T] {
	return Variant[T]{value: value}
}

func (v Variant[T]) Get() T {
	return v.value
}

func main() {
	// 创建不同类型的变体
	intVariant := NewVariant(42)
	strVariant := NewVariant("hello")
	floatVariant := NewVariant(3.14)

	// 获取值（类型安全）
	fmt.Printf("Integer: %d\n", intVariant.Get())
	fmt.Printf("String: %s\n", strVariant.Get())
	fmt.Printf("Float: %.2f\n", floatVariant.Get())
}

这些方法提供了类型安全且优雅的方式来处理混合类型元素，避免了使用unsafe.Pointer和显式类型转换。