未知具体类型时，如何将同类型interface{}赋值给指针型interface{}指向对象

先看问题场景代码：

type SameStructType struct{
    Test string
}

func A() interface{} {
    return SameStructType{
        Test:"123",
    }
}
func B() interface{} {
    return &SameStructType{}
}

a:=A()
b:=B()

// *b=a //I want to make b assigned by a.

已知具体类型时，直接用类型断言即可实现赋值：

a := A().(SameStructType)
b := B().(*SameStructType)
*b = a

针对未知具体类型但底层类型完全一致的场景，分情况解答：

1. 无需reflect的简便实现？ #

没有。Go是静态类型语言，所有赋值操作都依赖明确的类型信息。如果完全不知道具体类型，没办法绕过类型断言或reflect完成赋值——哪怕底层类型相同，Go的类型系统也不允许隐式的跨类型（哪怕是同结构、类型别名）赋值。

如果能提前预判可能的类型集合，可以用类型断言的分支逻辑覆盖，但这不属于“完全未知类型”的场景。

2. 必须用reflect的简便实现？ #

有，且性能并不像你担心的那样差。不需要逐字段解析，直接用reflect.Value.Set就能完成整值赋值：

import (
    "reflect"
    "fmt"
)

func assign(dst, src interface{}) error {
    dstVal := reflect.ValueOf(dst)
    // 目标必须是指针，才能修改其指向的值
    if dstVal.Kind() != reflect.Ptr {
        return fmt.Errorf("dst must be a pointer")
    }
    dstElem := dstVal.Elem()
    srcVal := reflect.ValueOf(src)

    // 检查底层类型是否完全一致
    if dstElem.Type() != srcVal.Type() {
        return fmt.Errorf("src and dst underlying type mismatch")
    }

    // 直接赋值，性能接近原生赋值
    dstElem.Set(srcVal)
    return nil
}

// 使用示例
err := assign(b, a)
if err != nil {
    // 处理错误
}

这个方法直接对整个值进行赋值，不是逐字段遍历，性能远高于手动解析字段的reflect实现。

3. 类似C/C++的内存拷贝方式？ #

可以用unsafe包实现，性能最高，但要承担类型安全风险：

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

func memcpyAssign(dst, src interface{}) error {
    dstVal := reflect.ValueOf(dst)
    if dstVal.Kind() != reflect.Ptr {
        return fmt.Errorf("dst must be a pointer")
    }
    srcVal := reflect.ValueOf(src)

    // 确认底层类型一致
    if dstVal.Elem().Type() != srcVal.Type() {
        return fmt.Errorf("src and dst underlying type mismatch")
    }

    // 获取内存指针和大小，直接拷贝
    dstPtr := unsafe.Pointer(dstVal.Pointer())
    srcPtr := unsafe.Pointer(srcVal.UnsafeAddr())
    size := srcVal.Type().Size()

    unsafe.Copy(dstPtr, srcPtr, size)
    return nil
}

// 使用示例
err := memcpyAssign(b, a)
if err != nil {
    // 处理错误
}

这种方式和C的memcpy逻辑一致，性能拉满，但unsafe会绕过Go的类型检查，必须确保dst和src的底层类型绝对一致，否则会触发内存错误、数据损坏等问题，生产环境使用要格外谨慎。

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