Question

我有一个结构A，用结构B扩展（“子类化”）它，如下所示：

package main

type A struct {
    x int
}

type B struct {
    A
    y int
}

我想创建一个数组，我可以在其中附加A或B，以便此代码有效：

func main() {
    var m [2]B

    m[0] = B { A { 1 }, 2 }
    m[0].x = 0
    m[0].y = 0

    m[1] = A { 3 }
    m[1].x = 0
}

没有。如果我创建了类型B的数组，我得到“不能在分配中使用struct literal（类型A）作为类型B”。如果我尝试创建类型A的数组，我会得到相同的错误（只是反转类型）。

所以我的问题是：数组应该是哪种类型？

Answer 1

您可以使用struct个值。例如，

package main

import "fmt"

type A struct {
    x int
}

type B struct {
    A
    y int
}

func main() {
    var m []interface{}
    m = append(m, B{A{1}, 2})
    m = append(m, A{3})
    fmt.Println(m[0], m[1])
    if b, ok := m[0].(B); ok {
        b.x = 0
        b.y = 0
        m[0] = b
    }
    if a, ok := m[1].(A); ok {
        a.x = 0
        m[1] = a
    }
    fmt.Println(m[0], m[1])
}

Output:
{{1} 2} {3}
{{0} 0} {0}

或者，您可以使用struct指针。例如，

package main

import "fmt"

type A struct {
    x int
}

type B struct {
    A
    y int
}

func main() {
    var m []interface{}
    m = append(m, &B{A{1}, 2})
    m = append(m, &A{3})
    fmt.Println(m[0], m[1])
    if b, ok := m[0].(*B); ok {
        b.x = 0
        b.y = 0
    }
    if a, ok := m[1].(*A); ok {
        a.x = 0
    }
    fmt.Println(m[0], m[1])
}

Output:
&{{1} 2} &{3}
&{{0} 0} &{0}

Answer 2

您需要将数组类型定义为interface{}而不是B。然后你可以在那里存储这两种类型。这是实现这一目标的唯一方法。如果两种类型都实现了特定的接口，那么您可以键入而不是通用的interface{}

创建扩展类型数组

2 个答案: