续日今天问我：Golang里面如何做结构体的深拷贝呢？他说他的excelize库被网友爆出一个Bug：
改变sheet2页上的数据，sheet1上的数据会一起发生变化，最后他定位到问题是由于自己做了两个sheet结构体的浅拷贝导致的。因为sheet对应的结构体的特殊性其必须是指针类型。是啊。。。这样就坑了，Golang里面怎么做一个超级无敌复杂结构体的指针变量的深拷贝呢？给个例子：

type KDeepCopy struct {
    A map[string]string

    B []string

    C struct {
        D [][]string
        E map[interface{}]F
        G string
        K func()
    }
}
type F struct {
    K map[int]*string
}

var k *KDeepCopy = &KDeepCopy{....} , var h *KDeepCopy。 这个时候想把k这个变量的内存中的值全部深拷贝到h这个变量上，即k和h指向不同内存区域。C++里面我们可以使用memcpy函数(或者类似的函数)来完成。但Golang官方没有提供这样的API函数给我们直接操作内存。这里给出一个解决方案(续神提供)，我写了简单的demo代码验证。demo中给了json和gob两种方法去解决，这两种编解码方案哪种更好，自己评鉴。

package main

import (
    "bytes"
    "encoding/gob"
    "encoding/json"
    "fmt"
)

type DeepCopy struct {
    A map[string]string
    B []string
    C Cc
}

type Cc struct {
    D map[int]*string
}

func main() {
    var F string = `fffffff`
    var E = map[int]*string{0: &F}
    var cc Cc = Cc{
        D: E,
    }
    var dc DeepCopy = DeepCopy{
        A: make(map[string]string, 0),
        B: []string{`b`, `c`, `d`},
        C: cc,
    }
    dv := DeepCopy{}
    dv = dc
    fmt.Printf("dc : %p\n", &dc)
    fmt.Printf("dv: %p\n", &dv)
    dv.B = []string{`f`, `g`, `d`}
    var K string = `kkkkkkk`
    dv.C.D[0] = &K
    fmt.Println(`dc:`, dc)
    fmt.Println(`dv:`, dv)
    fmt.Println(`df.C.D:`, *(dc.C.D[0]))
    fmt.Println(`dn.C.D:`, *(dv.C.D[0]))
    fmt.Println(`=============================`)
    var df *DeepCopy = &DeepCopy{
        A: make(map[string]string, 0),
        B: []string{`b`, `c`, `d`},
        C: cc,
    }
    dn := &DeepCopy{}
    dn = df // or *dn = *df
    fmt.Printf("dn : %p\n", dn)
    fmt.Printf("df: %p\n", df)
    dn.B = []string{`f`, `g`, `d`}
    var G string = `ggggggg`
    dn.C.D[0] = &G
    fmt.Println(`df:`, df)
    fmt.Println(`dn:`, dn)
    fmt.Println(`df.C.D:`, *(df.C.D[0]))
    fmt.Println(`dn.C.D:`, *(dn.C.D[0]))
    fmt.Println(`=============================`)
    var buf bytes.Buffer
    dg := &DeepCopy{}
    json.NewEncoder(&buf).Encode(*df)
    json.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dg)
    dg.B = []string{`h`, `j`, `k`}
    fmt.Println(dg.C.D)
    var W string = `wwwwwww`
    dg.C.D[0] = &W
    fmt.Printf("df : %p\n", df)
    fmt.Printf("dg: %p\n", dg)
    fmt.Println(`df:`, df)
    fmt.Println(`dg:`, dg)
    fmt.Println(`df.C.D:`, *(df.C.D[0]))
    fmt.Println(`dn.C.D:`, *(dg.C.D[0]))
    fmt.Println(`=============================`)
    var buff bytes.Buffer
    var FF string = `fffffff`
    var EE = map[int]*string{0: &FF}
    var cd Cc = Cc{
        D: EE,
    }
    var dx *DeepCopy = &DeepCopy{
        A: make(map[string]string, 0),
        B: []string{`b`, `c`, `d`},
        C: cd,
    }
    dj := &DeepCopy{}
    gob.NewEncoder(&buff).Encode(*dx)
    gob.NewDecoder(bytes.NewBuffer(buff.Bytes())).Decode(dj)
    dj.B = []string{`q`, `w`, `e`}
    var S string = `qqqqqqq`
    dj.C.D[0] = &S
    fmt.Printf("dx : %p\n", dx)
    fmt.Printf("dj: %p\n", dj)
    fmt.Println(`dx:`, dx)
    fmt.Println(`dj:`, dj)
    fmt.Println(`dx.C.D:`, *(dx.C.D[0]))
    fmt.Println(`dj.C.D:`, *(dj.C.D[0]))
    fmt.Println(`=============================`)
}

输出结果：

dc : 0x421210960
dv: 0x4212109f0
dc: {map[] [b c d] {map[0:0x421206670]}}
dv: {map[] [f g d] {map[0:0x421206670]}}
df.C.D: kkkkkkk
dn.C.D: kkkkkkk
=============================
dn : 0x421210b40
df: 0x421210ae0
df: &{map[] [b c d] {map[0:0x421206760]}}
dn: &{map[] [f g d] {map[0:0x421206760]}}
df.C.D: ggggggg
dn.C.D: ggggggg
=============================
map[0:0x421206a10]
df : 0x421210ae0
dg: 0x421210c00
df: &{map[] [b c d] {map[0:0x421206760]}}
dg: &{map[] [h j k] {map[0:0x421206a50]}}
df.C.D: ggggggg
dn.C.D: wwwwwww
=============================
dx : 0x421211080
dj: 0x4212110e0
dx: &{map[] [b c d] {map[0:0x421206b40]}}
dj: &{map[] [q w e] {map[0:0x4212070b0]}}
dx.C.D: fffffff
dj.C.D: qqqqqqq
=============================

是的，可以通过先把struct序列化保存到一个buffer里面，然后将buffer里面的Byte()数据进行反序列化到指定对象里面即可。是不是感觉好麻烦呢？如果你有什么好的方案，请在评论区贴出。