Go 는 값을 넘길 때 무엇을 복사하고, 언제 포인터를 씁니까?
Go 는 대입과 함수·메서드 호출에서 언제나 값을 복사합니다. 구조체는 필드 전체가 복사되고, 슬라이스·맵·문자열은 데이터가 아니라 작은 머리(헤더)만 복사됩니다. 고친 내용을 부른 쪽도 봐야 하거나 뮤텍스처럼 복사하면 안 되는 필드가 있으면 포인터를 넘깁니다. 연재 내내 키울 문의 보관함 inbox 의 타입을 만들며 확인합니다.
왼쪽 값 전달에서는 사본을 고쳐도 로봇이 든 원본이 그대로입니다. 오른쪽 포인터 전달에서는 꼬리표가 둘이어도 상자가 하나라서 누가 고치든 같은 상자가 바뀝니다.
구조체는 대입하고 넘길 때 통째로 복사된다
type Message struct {
Name string
Tags []string
}
func rename(m Message) { m.Name = "바뀐 이름" }
func renamePtr(m *Message) { m.Name = "바뀐 이름" }
func main() {
a := Message{Name: "처음", Tags: []string{"문의"}}
b := a // 필드 전체를 복사한다
b.Name = "사본"
rename(a) // 사본을 고친다
fmt.Println(a.Name, b.Name)
renamePtr(&a) // 주소를 넘긴다
fmt.Println(a.Name)
b.Tags[0] = "스팸" // 슬라이스는 머리만 복사됐다
fmt.Println(a.Tags[0])
}
처음 사본
바뀐 이름
스팸
b := a 와 rename(a) 는 사본을 만들고, &a 를 넘겨야 원본이 바뀝니다. 포인터로도 필드는 점으로 접근하며 포인터 연산(p + 1)은 컴파일 오류입니다. 마지막 줄이 함정입니다. 안의 슬라이스는 같은 배열을 가리켜서 b.Tags 를 고치면 a.Tags 도 바뀝니다.
| 넘기는 것 | Python·JavaScript·Java 객체 | Go 구조체 |
|---|---|---|
| 대입·호출 | 같은 객체를 가리킨다 | 필드 전체를 복사한다 |
| 함께 고치려면 | 그대로 넘긴다 | & 로 포인터를 넘긴다 |
제로 값만으로 쓸 수 있게 만든다
변수는 선언하는 순간 제로 값(0, "", false, nil)을 갖고, 표준 라이브러리에는 그 상태로 바로 쓰는 타입이 많습니다.
var buf bytes.Buffer // 만들지 않고 바로 쓴다
buf.WriteString("제로 값 그대로")
var mu sync.Mutex
mu.Lock()
mu.Unlock()
var names []string // nil 슬라이스에도 append 된다
names = append(names, "a")
var counts map[string]int // nil 맵은 읽기만 된다
fmt.Println(buf.String(), len(names), counts["x"], counts == nil)
제로 값 그대로 1 0 true
go doc bytes.Buffer 와 go doc sync.Mutex 는 제로 값이 바로 쓸 수 있는 상태라고 적습니다. 직접 만드는 타입도 이렇게 설계하면 초기화를 잊는 버그가 사라집니다. 아래 Inbox 는 맵을 처음 쓸 때 만들어서 var b Inbox 로 바로 씁니다.
설정값이 필요한 타입은 생성자 함수로 만든다
제로 값으로 정할 수 없는 설정이 있으면 NewX 함수를 둡니다. 이 사이트의 Go 서버에 있는 IP 당 요청 제한기입니다.
type Limiter struct {
mu sync.Mutex
hits map[string][]time.Time
limit int
window time.Duration
}
func NewLimiter(limit int, window time.Duration) *Limiter {
return &Limiter{hits: map[string][]time.Time{}, limit: limit, window: window}
}
모든 요청 처리기가 같은 기록을 봐야 하고 안의 뮤텍스는 복사하면 안 되므로 포인터를 돌려줍니다. Go 에는 생성자 문법이 없어 이 함수가 관례입니다.
고치는 메서드는 포인터 리시버로 쓴다
보관함 본체는 상태를 고치므로 리시버(receiver, 메서드를 받는 값)가 *Inbox 입니다.
// Inbox 는 메시지를 받은 순서대로 보관한다. 제로 값으로 바로 쓴다.
type Inbox struct {
mu sync.Mutex
msgs []Message
byID map[string]int
}
func (b *Inbox) Add(m Message) string {
b.mu.Lock()
defer b.mu.Unlock()
if b.byID == nil {
b.byID = map[string]int{}
}
m.ID = fmt.Sprintf("m%d", len(b.msgs)+1)
b.byID[m.ID] = len(b.msgs)
b.msgs = append(b.msgs, m)
return m.ID
}
같은 모양의 Get(id string) (Message, bool) 은 메시지를 값으로 돌려줍니다. 받은 쪽이 Body 를 고쳐도 보관함 안은 그대로이고, 테스트가 이것을 확인합니다. 리시버를 값으로 잘못 쓰면 어떻게 될까요? 뮤텍스가 든 카운터로 실험했습니다.
type Counter struct {
mu sync.Mutex
n int
}
func (c Counter) Inc() { // 값 리시버라서 사본의 n 을 올린다
c.mu.Lock()
defer c.mu.Unlock()
c.n++
}
$ go run .
0
$ go vet .
main.go:14:9: Inc passes lock by value: example.com/copylock.Counter contains sync.Mutex
Inc 를 두 번 불러도 0 이 나옵니다. 컴파일러는 막지 않고, go vet 의 copylocks 검사가 잡습니다. 리시버는 이렇게 고릅니다.
| 상황 | 리시버 |
|---|---|
| 필드를 고친다 | 포인터 |
| 뮤텍스처럼 복사하면 안 되는 필드가 있다 | 포인터 |
| 구조체가 크다(아래 “한 단계 더”) | 포인터 |
| 작고 바뀌지 않는 값이다 | 값. time.Time 이 예다(func (t Time) Add(d Duration) Time) |
값에는 포인터 리시버 메서드가 없다
type Inbox struct{ n int }
func (b *Inbox) Add(body string) int { b.n++; return b.n }
type Adder interface{ Add(body string) int }
func main() {
var box Inbox
box.Add("x") // 변수는 주소를 얻을 수 있어 (&box).Add 로 불린다
var a Adder = &box // *Inbox 는 Add 를 가진다
var b Adder = box // Inbox 값의 메서드 집합에는 Add 가 없다
_, _ = a, b
}
./main.go:14:16: cannot use box (variable of struct type Inbox) as Adder value in variable declaration: Inbox does not implement Adder (method Add has pointer receiver)
명세는 T 의 메서드 집합을 T 리시버 메서드로, *T 의 메서드 집합을 둘 다로 정합니다. box.Add("x") 는 컴파일러가 주소를 대신 잡아 줘서 되지만, 인터페이스에 넣을 때는 그 편의가 없습니다. 한 타입 안에서 리시버 종류를 섞지 않는 이유입니다.
임베딩은 상속이 아니라 필드를 끌어올린다
필드 이름 없이 타입만 적으면 그 필드와 메서드가 바깥 타입으로 올라옵니다(promotion).
type Stamp struct{ At time.Time }
func (s Stamp) Age(now time.Time) time.Duration { return now.Sub(s.At) }
type Message struct {
Stamp // 이름 없이 넣으면 필드와 메서드가 바깥으로 올라온다
Body string
}
m.Age(…) 와 m.At 이 바로 되고, 실행하면 1h30m0s true 가 나옵니다. 상속과 달리 Age 의 리시버는 안쪽 Stamp 이고, Message 를 Stamp 자리에 넘기면 cannot use m (variable of struct type Message) as Stamp value 로 거절됩니다.
올라온 메서드는 공개됩니다. sync.Mutex 를 이름 없이 넣은 타입과 mu 로 넣은 타입의 메서드를 reflect 로 세었습니다.
*main.Exposed [Lock TryLock Unlock]
*main.Hidden []
이름 없이 넣으면 Lock·Unlock 이 밖에 공개되므로 Inbox 와 Limiter 는 mu 로 이름을 붙였습니다.
구조체 태그는 JSON 이름을 정한다
필드 뒤 백틱 문자열이 태그이고, encoding/json 이 읽습니다.
type Message struct {
Name string `json:"name,omitempty"`
ReplyTo string `json:"replyTo"`
note string // 소문자 필드는 JSON 에 나가지 않는다
}
Message{ReplyTo: "a@example.com", note: "내부 메모"} 를 json.Marshal 하면 {"replyTo":"a@example.com"} 입니다. 빈 Name 은 omitempty 로, 소문자 note 는 공개되지 않아 빠졌습니다. 자세한 것은 4편에서 다룹니다.
슬라이스는 배열을 들여다보는 창이다
s := make([]int, 3, 5)
fmt.Println(len(s), cap(s), s)
t := s[1:3] // 같은 배열의 창
t[0] = 99
fmt.Println(s, len(t), cap(t))
t = append(t, 7) // 용량이 남아 같은 배열에 쓴다
fmt.Println(s[:5])
u := append(s, 1, 2, 3) // 용량을 넘어 새 배열로 옮긴다
u[0] = -1
fmt.Println(s[0], u[0], len(u), cap(u))
3 5 [0 0 0]
[0 99 0] 2 4
[0 99 0 7 0]
0 -1 6 10
len 은 지금 보이는 원소 수, cap 은 밑의 배열에 남은 자리입니다. s[1:3] 은 복사가 아니라 같은 배열의 창이라서 t[0] 을 고치면 s[1] 이 바뀝니다. append 는 자리가 남으면 같은 배열에 쓰고, 모자라면 새 배열로 옮깁니다. 그래서 append 의 결과는 항상 변수에 다시 받습니다. 늘어나는 규칙은 13편에서 봅니다.
맵은 순서를 지키지 않는다
같은 맵을 세 번 돌았습니다.
m := map[string]int{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
for range 3 {
var keys []string
for k := range m {
keys = append(keys, k)
}
fmt.Println(keys)
}
v, ok := m["z"] // 없으면 제로 값과 false
fmt.Println(v, ok)
fmt.Println(slices.Sorted(maps.Keys(m)))
[a b c d e]
[a b c d e]
[e a b c d]
0 false
[a b c d e]
세 번째 순서가 다릅니다. 명세도 맵 순회 순서는 정해지지 않았다고 적습니다. 순서가 필요하면 키를 정렬합니다. slices·maps 패키지는 Go 1.21 에 들어왔습니다. 반복자(iterator)를 쓰는 maps.Keys·slices.Sorted 는 Go 1.23 부터입니다. 정수를 도는 for range 3 은 Go 1.22 부터라서 go.mod 를 go 1.21 로 낮추면 requires go1.22 or later 로 거절됩니다. v, ok := m[k] 의 ok 는 “없음"과 “제로 값이 들어 있음"을 가릅니다.
문자열은 바이트의 나열이고 글자는 rune 이다
s := "안녕 Go"
fmt.Println(len(s), utf8.RuneCountInString(s))
for i, r := range s {
fmt.Printf("%d:%c ", i, r)
}
fmt.Println()
fmt.Println(s[0], s[:3], utf8.ValidString(s[:2]))
9 5
0:안 3:녕 6: 7:G 8:o
236 안 false
len 은 바이트 수이고, 한글은 UTF-8 로 3바이트라서 다섯 글자가 9바이트입니다. for range 는 글자(rune) 단위로 돌며 i 에 바이트 위치를 줍니다. 인덱스로 한글 중간을 자르면 올바르지 않은 UTF-8 이 됩니다. 이 사이트의 Go 서버는 이름·연락처·본문 길이 제한을 utf8.RuneCountInString 으로, 즉 글자 수로 잽니다.
한 단계 더 — 헤더 크기와 복사 비용
복사되는 머리는 몇 바이트일까요? unsafe.Sizeof 로 쟀습니다(arm64).
string 16 slice 24 map 8 pointer 8 any 16
Message 88 Inbox 40
문자열은 포인터·길이(16), 슬라이스는 포인터·길이·용량(24), 맵은 포인터(8)입니다. 넘겨도 데이터는 복사되지 않습니다. Message 는 문자열 넷과 time.Time 을 더한 88바이트입니다. any 의 16바이트는 14편에서 풉니다.
구조체를 값으로 넘기면 얼마나 느릴까요? 512바이트와 88바이트 구조체를 값과 포인터로 넘기는 벤치마크를 -benchmem -count 5 로 돌렸습니다. 함수에는 //go:noinline 을, 루프에는 Go 1.24 의 b.Loop 를 썼습니다. 표는 다섯 번의 중앙값입니다(2026-11-18, Apple M4 Pro, Go 1.26.2, 다른 작업과 함께 돌림).
| 함수 | ns/op (중앙값) | allocs/op |
|---|---|---|
| 512바이트 값 전달 | 7.021 | 0 |
| 512바이트 포인터 전달 | 1.631 | 0 |
| 88바이트 값 전달 | 1.888 | 0 |
| 88바이트 포인터 전달 | 1.945 | 0 |
512바이트는 호출마다 약 5.4ns 를 복사에 썼습니다. 88바이트는 차이가 없었습니다. 보통 크기의 구조체에서 포인터를 고르는 기준은 속도가 아니라 뜻(함께 고치는가, 복사하면 안 되는가)입니다.
포인터는 값을 힙으로 보낼 수 있습니다. 지역 변수의 주소를 돌려주는 함수를 go build -gcflags=-m 으로 빌드했습니다.
experiments/escape/main.go:9:2: moved to heap: m
experiments/escape/main.go:14:14: m does not escape
함수가 끝나도 살아야 하는 m 은 힙으로 갔고, 값으로 받아 길이만 쓴 m 은 스택에 남았습니다. 힙에 간 값은 가비지 컬렉터가 치웁니다(15·16편).
면접에서 이렇게 묻는다
Q1. 값 리시버와 포인터 리시버는 어떻게 고릅니까?
필드를 고치거나, 뮤텍스처럼 복사하면 안 되는 필드가 있거나, 구조체가 크면 포인터입니다. 작고 바뀌지 않는 값은 값 리시버이고 time.Time 이 예입니다. 한 타입 안에서는 섞지 않는다고 덧붙이고, 근거로 메서드 집합을 듭니다.
Q2. 포인터 리시버로 메서드를 만들었는데 왜 값이 인터페이스를 만족하지 못합니까?
명세상 T 의 메서드 집합에는 T 리시버 메서드만 있고, *T 에 둘 다 있습니다. 변수에서 v.M() 이 되는 것은 컴파일러가 (&v).M() 으로 바꿔 주기 때문이며 인터페이스 대입에는 이 변환이 없습니다.
Q3. 슬라이스를 함수에 넘기면 복사입니까, 참조입니까?
24바이트 헤더(포인터·길이·용량)가 복사됩니다. 원소를 고치면 부른 쪽도 봅니다. 함수 안의 append 는 용량에 따라 같은 배열에 쓰거나 새 배열로 옮기므로, 늘린 결과는 반환값으로 돌려줍니다.
Q4. 맵을 순회하는 순서에 기대도 됩니까? nil 맵은 어떻습니까?
안 됩니다. 명세가 순서를 정하지 않았고 실험에서도 바뀌었으니 필요하면 키를 정렬합니다(slices.Sorted(maps.Keys(m)), 1.23+). nil 맵은 읽기는 제로 값, 쓰기는 패닉입니다.
연습
연습 1 — 기본 태그를 붙였더니 다른 결과가 바뀐다
아래 withDefault 를 두 번 부르고 a[1] 만 고쳤는데 b[1] 이 바뀝니다. 이유를 설명하고 고칩니다.
func withDefault(tags []string) []string { return append(tags, "문의") }
base := make([]string, 1, 4)
base[0] = "일반"
a := withDefault(base)
b := withDefault(base)
a[1] = "스팸"
fmt.Println(b[1], len(base), cap(base))
풀이
실행하면 스팸 1 4 가 나옵니다. base 는 길이 1, 용량 4 라서 두 append 모두 같은 배열의 1번 칸에 썼고, a 와 b 는 같은 배열을 봅니다. 받은 슬라이스를 늘려 돌려줄 때는 먼저 복사합니다(slices.Clone, Go 1.21+).
func withDefaultSafe(tags []string) []string { return append(slices.Clone(tags), "문의") }
같은 순서로 부르고 c[1] 을 고치면 d[1] 은 문의 그대로입니다.
연습 2 — 한글을 글자 수로 자르기
미리보기에 본문 앞 n 글자만 보여 주려 합니다. s[:n] 은 바이트로 자르므로 한글이 깨집니다. 글자 단위로 자르는 Runes(s string, n int) string 을 쓰고 표 주도 테스트로 확인합니다.
풀이
for range 가 주는 바이트 위치를 씁니다. n 번째 글자가 시작하는 위치에서 자릅니다.
// Runes 는 s 를 앞에서부터 n 글자(rune)까지 남긴다.
func Runes(s string, n int) string {
count := 0
for i := range s { // i 는 각 글자가 시작하는 바이트 위치다
if count == n {
return s[:i]
}
count++
}
return s
}
표 주도 테스트는 ("안녕하세요", 2) → "안녕", ("Go 강의", 4) → "Go 강", ("안녕", 5) → "안녕", ("안녕", 0) → "" 를 돌고 결과가 올바른 UTF-8 인지도 봅니다. 모두 통과했고, 바이트로 자른 "안녕하세요"[:4] 는 utf8.ValidString 이 false 였습니다.
정리
Go 는 넘길 때마다 복사합니다. 구조체는 통째로, 슬라이스·맵·문자열은 머리만 복사됩니다. 함께 고치거나 복사하면 안 되는 것이 들었을 때 포인터를 넘기고, 리시버도 같은 기준으로 고릅니다.
3편에서는 이 타입들을 인터페이스로 이어 붙이고, 실패를 값으로 돌려주는 Go 의 에러 처리를 다룹니다. 이 편에서 본 메서드 집합이 인터페이스 구현을 정하는 규칙이 됩니다.