Golang 딥 카피

Golang 딥 카피
원형 디자인 모델 을 이해 하기 전에 우 리 는 Golang 의 깊 은 복사 와 얕 은 복사 간 의 차 이 를 새롭게 알 아야 한다.
Slice 와 Map 처럼 흔 한 구 덩이 를 새로 보 는 것 을 추천 합 니 다.https://blog.csdn.net/weixin_40165163/article/details/90707593
github:https://github.com/zhumengyifang/GolangDesignPatterns
데이터 구조:

//    
type Speed int

//    
type FanSpeed struct {
	Speed Speed
}

//  
type Money struct {
	Length float64
}

//        
type Memory struct {
	Count      int
	MemorySize []int
}

//    
type Computer struct {
	SystemName string              //    
	UseNumber  int                 //    
	Memory     Memory              //  
	Fan        map[string]FanSpeed //  
	Money      Money               //  
}

얕 은 복사:
 자바 나 C \ # 를 접 한 학생 들 은 얕 은 복사 가 값 유형 에 대해 서 는 완전히 복사 한 다 는 것 을 알 아야 하고 인용 유형 에 대해 서 는 주 소 를 복사 한 다 는 것 을 알 아야 한다.즉, 복사 대상 이 인용 형식 을 수정 하 는 변 수 는 원본 대상 에 도 영향 을 줄 수 있다.
여기 서 Golang 은 상기 테스트 유형 에서 Slice 와 Map 의 수정 과 관련 된 것 은 서로 영향 을 줄 수 있다.
테스트 1:

func ComputerStart1() {
	Pc1 := Computer{
		SystemName: "Windows",
		UseNumber:  1000,
		Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},
		Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},
		Money:      Money{123.45},
	}

    //   
	Pc2:=Pc1
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)
    //        map    Pc1
    Pc2.SystemName ="MacOs"
	Pc2.UseNumber =100
    Pc2.Memory.Count =2
    Pc2.Memory.MemorySize[0]=8
	Pc2.Memory.MemorySize[1]=8
	Pc2.Memory.MemorySize[2]=0
	Pc2.Memory.MemorySize[3]=0
	Pc2.Fan["left"]=FanSpeed{2000}
	Pc2.Fan["right"]=FanSpeed{1500}
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)
}

 입력 정보:

PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}, Pc2:{MacOs 100 {2 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}

PC2 에 대한 수정 은 PC1 의 Slice 와 Map 에 영향 을 주 었 습 니 다.
테스트 2:

func ComputerStart2() {
	Pc1 := Computer{
		SystemName: "Windows",
		UseNumber:  1000,
		Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},
		Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},
		Money:      Money{123.45},
	}

    //   
	Pc2:=Pc1
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)

	ModifyCat(Pc2)
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)
}

func ModifyCat(pc Computer) {
	fmt.Printf("PcInfo Pc1:%v
", pc)
	pc.SystemName ="MacOs"
	pc.UseNumber =100
	pc.Memory.Count =2
	pc.Memory.MemorySize[0]=8
	pc.Memory.MemorySize[1]=8
	pc.Memory.MemorySize[2]=0
	pc.Memory.MemorySize[3]=0
	pc.Fan["left"]=FanSpeed{2000}
	pc.Fan["right"]=FanSpeed{1500}
	fmt.Printf("PcInfo Pc1:%v
", pc)
}

입력:

PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{MacOs 100 {2 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}, Pc2:{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}

여기 서 방법 에서 PC2 를 수정 하 는 것 도 PC1 과 PC2 에 영향 을 미 쳤 다. Golang 에서 방법 으로 전달 하 는 매개 변수 가 똑 같이 복사 되 었 기 때문이다. 그들 이 수정 한 Slice 와 Map 은 모두 같은 주소 이기 때문이다.
그렇다면 얕 은 복사 에 있어 서 어떻게 이런 상황 을 피 할 수 있 습 니까?
테스트 3:

func ComputerStart2() {
	Pc1 := Computer{
		SystemName: "Windows",
		UseNumber:  1000,
		Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},
		Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},
		Money:      Money{123.45},
	}

    //   
	Pc2:=Pc1
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)
    //    map       
    Pc2.SystemName ="MacOs"
	Pc2.UseNumber =100
	Pc2.Memory =Memory{Count: 2, MemorySize: []int{8, 8}}
	Pc2.Fan =map[string]FanSpeed{"left": {2000}, "right": {1500}}
	Pc2.Money =Money{1000.45}
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)
}

출력:

PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:{MacOs 100 {2 [8 8]} map[left:{2000} right:{1500}] {1000.45}}

Slice 와 Map 만 영향 을 받 을 수 있 으 니 주 소 를 다시 정 해서 Slice 와 Map 을 만 들 면 영향 을 받 지 않 습 니 다.
딥 카피
깊 은 복사 에 대해 잘 알 수 있 습 니 다. 그 어떠한 대상 도 완전 하 게 복사 되 고 복사 대상 과 피 복사 대상 은 어떻게 연결 되 지 않 으 며 서로 영향 을 주지 않 습 니 다.복사 할 대상 에 인용 형식 이 없다 면 골 랑 에 게 는 얕 은 복사 본 을 사용 하면 된다.
직렬 화 와 반 직렬 화 를 바탕 으로 대상 의 깊이 있 는 복사:

func deepCopy(dst, src interface{}) error {
    var buf bytes.Buffer
    if err := gob.NewEncoder(&buf).Encode(src); err != nil {
        return err
    }
    return gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst)
}

깊이 복사 해 야 하 는 변 수 는 이니셜 대문자 가 있어 야 복사 할 수 있 습 니 다.
테스트 1:

func ComputerStart4() {
	Pc1 := &Computer{
		SystemName: "Windows",
		UseNumber:  1000,
		Memory:     Memory{Count: 4, MemorySize: []int{32, 32, 32, 32}},
		Fan:        map[string]FanSpeed{"left": {2500}, "right": {2000}},
		Money:      Money{123.45},
	}

	//   
	Pc2:= new(Computer)
	if err:= deepCopy(Pc2,Pc1);err!=nil{
          panic(err.Error())
	}
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)

	ModifyCat1(*Pc2)
	fmt.Printf("PcInfo Pc1:%v, Pc2:%v
", Pc1, Pc2)
}

출력:

PcInfo Pc1:&{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:&{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}
PcInfo Pc1:{MacOs 100 {2 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}
PcInfo Pc1:&{Windows 1000 {4 [32 32 32 32]} map[left:{2500} right:{2000}] {123.45}}, Pc2:&{Windows 1000 {4 [8 8 0 0]} map[left:{2000} right:{1500}] {123.45}}

PC2 가 얕 은 복사 (파라미터 전달) 를 거 쳐 Slice 와 Map 을 수정 하 는 데 영향 을 받 는 것 도 PC2 와 PC2 의 얕 은 복사 대상 만 볼 수 있다.PC1 에는 아무런 영향 이 없다.
다음 장 원형 디자인 모델:https://blog.csdn.net/weixin_40165163/article/details/90671135