go语言中如何将带有map的结构体存储到数组中

Question

I made a package that looks like this...

package foo
type Foo struct {
    num   int
    aMap  map[int](int)
}

func MakeFoo() BookState {
    return Foo{
        num:  -1,
        aMap: make(map[int](int)),
    }
}

I'm processing rows of a file like this

nrows :=100
arrayFoo = make([]Foo, nrows)
Foo = foo.MakeFoo()
count := 0
for int i=0; i < nrows; i++ {
   row = myWrappedReader.ReadLine()
   foo.num = i
   foo.aMap[key] += row.otherNum
   arrayFoo[i] = foo
}

But then when I go to check the arrayFoo at the end I have something that looks like this [{num:1, aMap:{/*final state*/}, {num:2, aMap:{/*final state*/}, ...]

So the integer is updating but I need a copy of aMap to be stored instead of just the pointer to aMap .

---

Update:

Here's a playground .

Update2:

Here's a version that works . My class is quite a bit more complicated than this so I think I'll write a helper function in package foo that clone it.

Answer 1

Is there a easier way to copy maps or do most people do that?

Anything requiring a deep copy, as mentioned in " Is there a built in function in go for making copies of arbitrary maps? ", would involve a dedicated function.

Example in this gist :

package deepcopy

import (
    "bytes"
    "encoding/gob"
)

func init() {
    gob.Register(map[string]interface{}{})
}

// Map performs a deep copy of the given map m.
func Map(m map[string]interface{}) (map[string]interface{}, error) {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    dec := gob.NewDecoder(&buf)
    err := enc.Encode(m)
    if err != nil {
        return nil, err
    }
    var copy map[string]interface{}
    err = dec.Decode(&copy)
    if err != nil {
        return nil, err
    }
    return copy, nil
}

Answer 2

Based on the suggestion of mkopriva replacing the line foo.aMap[key] += i with foo.aMap = map[string]int{"key": foo.aMap[key] + i}

package main

import (
    "fmt"
)

type Foo struct {
    num  int
    aMap map[string](int)
}

func MakeFoo() Foo {
    return Foo{
        num:  -1,
        aMap: make(map[string](int)),
    }
}

func main() {
    foo := MakeFoo()

    key := "tmp"
    foo.aMap[key] = 0

    fmt.Println(foo)
    arrayFoo := make([]Foo, 10)
    for i := 0; i < 10; i++ {
        foo.num = i
        foo.aMap = map[string]int{"key": foo.aMap[key] + i}
        arrayFoo[i] = foo
    }
    fmt.Println(arrayFoo)
}

Output:

{-1 map[tmp:0]}
[{0 map[key:0]} {1 map[key:1]} {2 map[key:2]} {3 map[key:3]} {4 map[key:4]} {5 map[key:5]} {6 map[key:6]} {7 map[key:7]} {8 map[key:8]} {9 map[key:9]}]