How to deep copy a struct in Go

Overview

The Go language creates a deep copy of structs with primitive type fields by default. However, there is no built-in function to deep copy a struct that includes references. We can use a third-party provider to do this, or in the case that there is no third-party package or we simply don’t want to use it, we can build one ourselves.

To read more on the differences between deep copying and shallow copying, check this Answer.

Before seeing how to deep copy a struct, let’s look at how we can perform a shallow copy first.

Shallow copying a `struct`

Syntax

``` struct2 := &struct1 ``` For a `pointer` referencing a `struct`, we simply use an assignment operator to create a shallow copy. 
struct2 := struct1

Example code

package main
import "fmt"
type DemoStruct struct{name string; value int}
func main(){
  struct1 := DemoStruct{name: "int", value: 30}
  fmt.Println(struct1.name)
  struct2 := &struct1
  struct2.name = "string"
  fmt.Printf("Struct1 : %s\nStruct2 : %s\n",struct1.name, struct2.name)
  fmt.Println(&struct1 == struct2)
}

Explanation

- Line 8: We copy the reference of `struct1` to a new variable `struct2`. - Line 9: We change `name` to `string` in `struct2`. - Line 12: We compare the memory addresses and then print the result. Note that the memory address is the same and that `struct1` also reflects the change.

Deep copying a `struct`

Deep copying a `struct` depends on one's code implementation. The core concept is the same as that of shallow copying, namely we remove the reference and manually copy the content. However, the functions and the strategy may vary depending on the given scenario.

Syntax

struct2 := struct1

This will only work for a struct with primitive fields.

For a pointer referencing a struct, we use * to dereference it before creating its copy.

Deep copying `struct` with an array field

Here we use the append function, but we can also use the map function to achieve the same functionality.

package main
import "fmt"
type DemoStruct struct{
  name string
  value  int
  arr []string
}
func main() {
  p := DemoStruct{
    value:  20,
    name: "Struct1",
    arr: []string{"city1"},
  }
  q:=p
  q.arr = nil
  q.arr = append(q.arr,p.arr...)
  q.arr[0]= "Altered"
  fmt.Println(p)
  fmt.Println(q)
  fmt.Println(&p == &q)
}

Explanation

- Line 17: We assign `nil` to `arr` and remove the reference of the original array. - Line 18: We create a new copy by appending all the elements to the empty array. - Line 19: We change the first element of the struct `q`. Notice that this change is not reflected in the `arr` field of struct `p`.

Deep copying `struct` with a pointer field

package main
import "fmt"
type DemoStruct struct{
  name string
  value  int
  s_pointer *string
}
func main() {
  x:= "Original"
  p := DemoStruct{ value: 20, name: "Struct1", s_pointer: &x }
  q:=p
  q.s_pointer = nil
  y:= *p.s_pointer
  q.s_pointer = &y
  *q.s_pointer = "Altered"
  fmt.Println(*p.s_pointer)
  fmt.Println(*q.s_pointer)
  fmt.Println(&p.s_pointer == &q.s_pointer)
}

Explanation

- Line 13: We create a shallow copy of the `struct`. - Line 14: We remove the reference by assigning `nil` to `s_pointer` of `q`. - Line 15: We dereference `p.s_pointer` by using `*`. We then copy its content to variable `y`. - Line 16: We assign a reference of `y` to `q.s_pointer`.

We do not recommend that the unsafe-package be used for doing this.

Free AI Mock Interviews
Coding Interview
Coding PatternsFree Interview
Gain insights and practical experience with coding patterns through targeted MCQs and coding problems, designed to match and challenge your expertise level.
System Design
YouTubeFree Interview
Learn to design a video streaming platform like YouTube by tackling functional and non-functional requirements, core components, and high-level to detailed design challenges.

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved