Go语言讲解深拷贝与浅拷贝

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

我们在开发中会经常的把一个变量复制给另一个变量，那么这个过程，可能是深浅拷贝，那么今天帮大家区分一下这两个拷贝的区别和具体的区别。

一、概念
1、深拷贝（Deep Copy）：

拷贝的是数据本身，创造一个样的新对象，新创建的对象与原对象不共享内存，新创建的对象在内存中开辟一个新的内存地址，新对象值修改时不会影响原对象值。既然内存地址不同，释放内存地址时，可分别释放。

值类型的数据，默认全部都是深复制，Array、Int、String、Struct、Float，Bool。

2、浅拷贝（Shallow Copy）：

拷贝的是数据地址，只复制指向的对象的指针，此时新对象和老对象指向的内存地址是一样的，新对象值修改时老对象也会变化。释放内存地址时，同时释放内存地址。

引用类型的数据，默认全部都是浅复制，Slice，Map。

二、本质区别：
是否真正获取（复制）对象实体，而不是引用。

三、如何理解？
这里举个例子，比如P2复制了P1，修改P1属性的时候，观察P2的属性是否会产生变化

1、P2的属性变化了，说明这是浅拷贝，堆中内存还是同一个值。

p2=&p1 // 浅拷贝，p2为指针，p1和p2共用一个内存地址
2、P2的属性没变化，说明这是深拷贝，堆中内存是不同的值了。

p2=p1 // 深拷贝，生成两个内存地址
四、演示示例：
深拷贝示例：

package main

import (
   "fmt"
)

// 定义一个Robot结构体
type Robot struct {
   Name  string
   Color string
   Model string
}

func main() {
   fmt.Println("深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。")
   robot1 := Robot{
      Name:  "小白-X型-V1.0",
      Color: "白色",
      Model: "小型",
   }
   robot2 := robot1
   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)

   fmt.Println("修改Robot1的Name属性值")
   robot1.Name = "小白-X型-V1.1"

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, &robot2)

}

运行结果：

深拷贝 内容一样，改变其中一个对象的值时，另一个不会变化。
Robot 1：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072360
修改Robot1的Name属性值
Robot 1：{小白-X型-V1.1 白色 小型}      内存地址：0xc000072330
Robot 2：{小白-X型-V1.0 白色 小型}      内存地址：0xc000072360

深拷贝中，我们可以看到Robot1号的地址与Robot2号的内存地址是不同的，修改Robot1号的Name属性时，Robot2号不会变化。

浅拷贝我们用两种方式来介绍。

浅拷贝示例1：

package main

import (
   "fmt"
)

// 定义一个Robot结构体
type Robot struct {
   Name  string
   Color string
   Model string
}

func main() {

   fmt.Println("浅拷贝 内容和内存地址一样，改变其中一个对象的值时，另一个同时变化。")
   robot1 := Robot{
      Name:  "小白-X型-V1.0",
      Color: "白色",
      Model: "小型",
   }
   robot2 := &robot1
   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)

   fmt.Println("在这里面修改Robot1的Name和Color属性")
   robot1.Name = "小黑-X型-V1.1"
   robot1.Color = "黑色"

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, &robot1)
   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)

}

运行结果1：

浅拷贝 内容和内存地址一样，改变其中一个对象的值时，另一个同时变化。
Robot 1：{小白-X型-V1.0 白色 小型}      内存地址：0xc000062330
Robot 2：&{小白-X型-V1.0 白色 小型}     内存地址：0xc000062330
在这里面修改Robot1的Name和Color属性
Robot 1：{小黑-X型-V1.1 黑色 小型}      内存地址：0xc000062330
Robot 2：&{小黑-X型-V1.1 黑色 小型}     内存地址：0xc000062330

浅拷贝中，我们可以看到Robot1和Robot2的内存地址是相同的，修改其中一个对象的属性时，另一个也会产生变化。

浅拷贝示例2：

package main

import (
   "fmt"
)

// 定义一个Robot结构体
type Robot struct {
   Name  string
   Color string
   Model string
}

func main() {

   fmt.Println("浅拷贝 使用new方式")
   robot1 := new(Robot)
   robot1.Name = "小白-X型-V1.0"
   robot1.Color = "白色"
   robot1.Model = "小型"

   robot2 := robot1
   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)

   fmt.Println("在这里面修改Robot1的Name和Color属性")
   robot1.Name = "小黑-X型-V1.2"
   robot1.Color = "黑色"

   fmt.Printf("Robot 1：%s\t内存地址：%p \n", robot1, robot1)
   fmt.Printf("Robot 2：%s\t内存地址：%p \n", robot2, robot2)
}

运行结果：

浅拷贝 使用new方式
Robot 1：&{小白-X型-V1.0 白色 小型}     内存地址：0xc000068330
Robot 2：&{小白-X型-V1.0 白色 小型}     内存地址：0xc000068330
在这里面修改Robot1的Name和Color属性
Robot 1：&{小黑-X型-V1.2 黑色 小型}     内存地址：0xc000068330
Robot 2：&{小黑-X型-V1.2 黑色 小型}     内存地址：0xc000068330

new操作，robot2 := robot1，看上去是深拷贝，其实是浅拷贝，robot2和robot1两个指针共用同一个内存地址。

参考：https://www.cnblogs.com/guichenglin/p/12736203.html