级联保存映射结构的空括号初始值

本文讨论了级联保存映射结构中的空括号初始值问题。作者提供了两个示例，其中一个不起作用，原因是 addxxx 函数返回副本而不是指针。为了解决此问题，作者建议将 addxxx 函数的返回类型更改为指针，并使用指针创建对象。作者还强调了返回指针和值之间的语义差异，并提供了在不同情况下使用指针和值的示例。

我有以下数据结构。它是一个结构体链，每个结构体都有map[string]t。基本上我将复杂的 yaml 文件序列化为数据结构。我有两个版本可以工作，但一个版本不行，我不清楚为什么？根据我的理解，go 编译器非常智能，因此它应该找出需要分配对象的位置。

请考虑下面的代码。

type userdata struct {
    username string
    password string
}
type groups struct {
    users map[string] userdata
}
type cluster struct {
    group map[string] groups
}
type director struct {
    cluster map[string]cluster
}

//... i removed other add function.. same semantic each add x function 
// check if a map is nil call make(map[string]t) add a key)
// add a key with struct (where struct hold nil map)
func (c *cluster) addgroup(groupname string) group {
    if c.group == nil {
        c.group = make(map[string]groups)
    }

        c.group[groupname] = groups {}
        group, _ := c.group[groupname]
        return group
}

func (p *director) addcluster(clustername string) cluster {
    if p.cluster == nil {
        p.cluster = make(map[string]cluster)
    }

    p.cluster[clustername] = cluster{}
    cluster, _ := p.cluster[clustername]
    return cluster
    // does a compiler here allocate an object on the 
    // stack for cluster {} and it goes out of a scope ? 

}

如果调用者做了类似的事情

var p = director{}
cluster := p.addcluster("test cluster")
cluster.addgroup("test group")

它不起作用——第一次调用确实创建了一个映射并放置了一个值，但第二次调用不起作用。该密钥永远不会添加到第二张地图中。

在一个有效的版本中，我创建了一个有效的构造函数（每个方法中的语义相同）。例如，下面的版本可以工作。 （我在这里使用与 c++ 和其他语言相同的语义）

func NewCluster() *Cluster {
    var cluster = Cluster{}
    cluster.Group = make(map[string]Groups)

    return &cluster
}

func (p *Director) AddCluster(clusterName string) {
    if p.Cluster == nil {
        p.Cluster = make(map[string]Cluster)
    }

    p.Cluster[clusterName] = *NewCluster()
}

我想当你习惯了一种语言编译器的魔力会让生活变得更加困难:)

解决方案

对，问题是您的 addxxx 函数正在返回副本/值，如果您希望代码正常工作，它们应该返回指针。您还必须将 addgroup 函数的返回类型更改为 groups （并可能重命名该函数以反映实际类型名称）。当文字较短且更惯用时，我还会避免使用 make。

func (c *cluster) addgroup(groupname string) *groups {
    if c.group == nil {
        c.group = map[string]*groups{} // change type to use pointers
    }

    group := &groups{} // create pointer
    c.group[groupname] = group // assign
    return group // return
}

func (p *director) addcluster(clustername string) *cluster {
    if p.cluster == nil {
        p.cluster = map[string]*cluster{} // change type
    }

    cluster := &cluster{} // create ptr var
    p.cluster[clustername] = cluster
    return cluster
}

您遇到的问题与分配对象的位置无关，而是与您正在使用的对象有关。如果您调用 addcluster，并且不返回指针，则对返回的 cluster 对象 (addgroup) 的调用将向与您在地图中的对象完全不同的对象添加一个组。已经创建了。您正在做的 c/c++ 相当于以下内容：

typedef _cluster_t struct {
    int foo;
} cluster;

// and some calls like this:

int add_foo(cluster *c) {
    c->foo = 123;
    return c->foo;
}

int main ( void ) {
   cluster cl;
   int i = add_foo(&cl);
   i++;
   printf("i expect %d == %d\n", i, cl.foo);
   return 0;
}

很明显，您正在增加分配给 cl.foo 的 int val 的副本。您不会同时更新两者。

更新（澄清）：

指针变量可以分配在堆栈或堆上，这由运行时决定。然而，因为值与指针返回在语义/功能上是不同的。如果编译器基于任何原因做出假设，我们都会陷入一个受伤的世界。考虑一个大量使用并发的程序中的以下代码：

type foo struct {
    somedata map[string]bar
}

func (f *foo) addbar(name string) bar {
    if f.somedata == nil {
        f.somedata = map[string]bar{} // this already is not thread-safe!
    }
    b := bar{}
    f.somedata[name] = b
    return b
}

如果返回值 b 将“秘密” 作为指针返回，但另一个例程也在更新相同的值，那么就会出现竞争条件。此外，在很多合法的情况下，您确实不需要指针：

type foo struct {
    mu *sync.mutex
    data map[string]*bar
}
// getbar - should return a snapshot of whatever bar looks like at this moment
func (f *foo) getbar(name string) (bar, error) {
    f.mu.lock()
    defer f.mu.unlock()
    if b, ok := f.data[name]; ok {
        // return copy because it's a snapshot!
        return *b, nil
    }
    return bar{}, errbarnotfound
}

tbh，在这种 getbar 函数中，我可能会返回一个指针，但像这样返回它：

if b, ok := f.data[name]; ok {
    cpy := *b // create copy/snapshot
    return &cpy, nil
}
// so in case of an error, I can return nil:
return nil, ErrBarNotFound

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。