Go泛型函数如何初始化结构体指针？类型兼容方案探讨

1. 让B[*Person]()返回指向空结构体的指针 #

原函数B中，当类型参数是*Person时，*new(Person)等价于对**Person类型的值解引用，得到的是nil的*Person。要返回指向空结构体的指针，我们可以通过反射判断类型参数是否为指针，针对性创建实例：

package main

import (
	"fmt"
	"reflect"
)

func A() (p *Person) {
	p = new(Person)
	return
}

func B[T any]() T {
	var zero T
	typ := reflect.TypeOf(zero)
	if typ.Kind() == reflect.Ptr {
		// 如果是指针类型，创建其元素类型的实例并返回指针
		elemInstance := reflect.New(typ.Elem())
		return elemInstance.Interface().(T)
	}
	// 非指针类型，返回初始化后的结构体值
	return *new(T)
}

type Person struct {
	Name string
	Age  int
}

func main() {
	fmt.Println(A())                  // &{ 0}
	fmt.Println(B[Person]())          // { 0}
	fmt.Println(B[*Person]())         // &{ 0}
	fmt.Println(B[*int]())            // 0x...（指向0的int指针）
}

如果不想用反射，也可以针对Person和*Person做类型分支（适合特定类型场景）：

type PersonOrPtr interface {
	Person | *Person
}

func B[T PersonOrPtr]() T {
	switch t := any(new(T)).(type) {
	case **Person:
		// T是*Person时，new(T)是**Person，返回&Person{}
		return any(&Person{}).(T)
	case *Person:
		// T是Person时，new(T)是*Person，解引用返回初始化值
		return *t
	default:
		return *new(T)
	}
}

2. 处理Person和*Person类型，或限制传入类型 #

方式一：限制只能传入Person或*Person #

通过定义联合类型约束，可以限定用户只能传入Person或*Person作为类型参数，避免传入其他无关类型：

// 定义约束，只允许Person和*Person
type PersonOrPtr interface {
	Person | *Person
}

// 泛型函数使用该约束
func B[T PersonOrPtr]() T {
	var zero T
	typ := reflect.TypeOf(zero)
	if typ.Kind() == reflect.Ptr {
		return reflect.New(typ.Elem()).Interface().(T)
	}
	return *new(T)
}

此时如果用户传入B[int]()，编译器会直接报错，达到限制效果。

方式二：自动处理任意指针/非指针类型 #

如果不需要限制类型，希望函数能处理任意类型的指针和非指针（比如int、*int等），直接用前面的反射版本即可，它会自动判断类型：

• 当传入值类型（如Person、int），返回初始化后的实例；
• 当传入指针类型（如*Person、*int），返回指向对应空实例的指针。

内容的提问来源于stack exchange，提问作者Matt