[Go] 슬라이스(slice)에는 포인터가 있다

 

 

시작

슬라이스는 Go에서 가변길이 배열입니다. 고정길이 배열은 var arr [10]int 이지만 슬라이스는 var slice []int입니다.
초기 슬라이스는 빈 배열입니다.

package main

import "fmt"

func main() {
	var slice []int

	if len(slice) == 0 { // ❶ slice 길이가 0인지 확인
		fmt.Println("slice is empty", slice)
	}

	slice[1] = 10 // ❷ 에러 발생
	fmt.Println(slice)
}

 

초기화

[] 이용

var slice1 = []int{1, 2, 3}
var slice2 = []int{1, 5:2, 10:3} // [1 0 0 0 0 2 0 0 0 0 3] //인덱스 5는 2, 10은 3

make() 이용

var slice = make([]int, 3)

 

요소 추가

//ch18/ex18.3/ex18.3.go
package main

import "fmt"

func main() {
	var slice []int

	for i := 1; i <= 10; i++ { // ❶ 요소를 하나씩 추가
		slice = append(slice, i)
	}

	slice = append(slice, 11, 12, 13, 14, 15) // ❷ 한 번에 여러 요소 추가
	fmt.Println(slice)
}

 

슬라이스 내부 구조

• ptr (*Elem): 배열 요소를 가리키는 포인터입니다.
• len (int): 슬라이스의 현재 길이, len() 함수로 확인할 수 있습니다.
• cap (int): 슬라이스의 최대 용량, cap() 함수로 확인할 수 있습니다.

 

Golang 슬라이스를 조작할 때 (예: 요소 추가, 제거), Go 런타임은 이 내부 구조를 업데이트합니다. 용량을 초과하면 새로운 배열이 할당되고 데이터가 복사됩니다. 실제 Go 코드에서는 이 내부 구조에 직접 접근할 수 없습니다. 슬라이스 조작은 언어에서 제공하는 내장 함수와 문법을 통해 이루어집니다.

https://medium.com/@oneee/go%EC%9D%98-slice-%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-b720226adee4

 

 

배열과의 차이

package main

import "fmt"

func changeArray(array2 [5]int) { // ❶ 배열을 받아서 세 번째 값 변경
	array2[2] = 200
}

func changeSlice(slice2 []int) { // ❷ 슬라이스를 받아서 세 번째 값 변경
	slice2[2] = 200
}

func main() {
	array := [5]int{1, 2, 3, 4, 5}
	slice := []int{1, 2, 3, 4, 5}

	changeArray(array)
	changeSlice(slice)

	fmt.Println("array:", array)
	fmt.Println("slice:", slice)
}

// array: [1 2 3 4 5]
// slice: [1 2 200 4 5]

Go 언어에서는 모든 값의 대입은 복사입니다. 함수에 인수로 전달될 때나 다른 변수 대입할 때 값의 이동은 복사입니다. 슬라이스는 포인터가 가리키는 주소가 복사되기 때문에 복사된 슬라이스도 같은 배열 데이터를 가리키게 됩니다.

append시 주의사항

package main

import "fmt"

func main() {
	slice1 := make([]int, 3, 5) // ❶ len:3 cap:5 슬라이스를 만듭니다

	slice2 := append(slice1, 4, 5)
	// cap() 함수를 이용해 슬라이스 capacity 값을 알 수 있습니다.
	fmt.Println("slice1:", slice1, len(slice1), cap(slice1))
	fmt.Println("slice2:", slice2, len(slice2), cap(slice2))

	slice1[1] = 100 // ❷ slice2까지 바뀝니다.

	fmt.Println("After change second element")
	fmt.Println("slice1:", slice1, len(slice1), cap(slice1))
	fmt.Println("slice2:", slice2, len(slice2), cap(slice2))

	slice1 = append(slice1, 500) // ❸ 역시 slice2까지 바뀝니다.

	fmt.Println("After append 500")
	fmt.Println("slice1:", slice1, len(slice1), cap(slice1))
	fmt.Println("slice2:", slice2, len(slice2), cap(slice2))
}

/*
slice1: [0 0 0] 3 5
slice2: [0 0 0 4 5] 5 5
After change second element
slice1: [0 100 0] 3 5
slice2: [0 100 0 4 5] 5 5
After append 500
slice1: [0 100 0 500] 4 5
slice2: [0 100 0 500 5] 5 5
*/

append함수의 결과는 새로운 슬라이스를 반환합니다. slice1에 append함수를 적용시켜 새로운 slice2를 만들게 되면, slice1과 slice2가 모두 같은 배열을 가리키기 때문에 위 현상이 일어납니다.

만약 위 예제에서 len 3, cap 3인 slice1으로 하면 어떻게 될까요?

package main

import "fmt"

func main() {
	slice1 := []int{1, 2, 3} // ❶ len:3 cap:3 슬라이스 생성

	slice2 := append(slice1, 4, 5) // ❷ append() 함수로 요소 추가

	fmt.Println("slice1:", slice1, len(slice1), cap(slice1))
	fmt.Println("slice2:", slice2, len(slice2), cap(slice2))

	slice1[1] = 100 // ❸ slice1 요솟값 변경

	fmt.Println("After change second element")
	fmt.Println("slice:", slice1, len(slice1), cap(slice1))
	fmt.Println("slice2:", slice2, len(slice2), cap(slice2))

	slice1 = append(slice1, 500) // ➍ slice1 요솟값 변경

	fmt.Println("After append 500")
	fmt.Println("slice1:", slice1, len(slice1), cap(slice1))
	fmt.Println("slice2:", slice2, len(slice2), cap(slice2))
}

/*
slice1: [1 2 3] 3 3
slice2: [1 2 3 4 5] 5 6
After change second element
slice: [1 100 3] 3 3
slice2: [1 2 3 4 5] 5 6
After append 500
slice1: [1 100 3 500] 4 6
slice2: [1 2 3 4 5] 5 6
*/

append할 때 빈 공간이 없는 경우에는 길이 6개짜리(cap:3 * 2) 새로운 배열을 만든뒤 slice1 배열의 모든 값을 복사하고 맨 뒤에 4, 5를 추가해서 len: 5, cap: 6 슬라이스를 반환합니다. 따라서 새 슬라이스를 대입한 slice2은 slice1과 다른 배열을 가리킵니다.

결론적으로 append()는 슬라이스가 가리키는 배열에 빈 공간이 충분하다면 추가하고 그렇지 않다면 더 큰 새로운 배열을 만들어서 추가한다는 점을 기억해야합니다. 이 부분을 잘 인지해서 예기치 못한 버그가 발생하지 않도록 해야 합니다.

슬라이스 복제

make로 새로운 슬라이스를 만드는 것이 가장 확실한 방법입니다.

package main

import "fmt"

func main() {
	slice1 := []int{1, 2, 3, 4, 5}

	slice2 := make([]int, len(slice1)) // ❶ slice1과 같은 길이의 슬라이스 생성

	for i, v := range slice1 { // ❷ slice1의 모든 요소값 복사
		slice2[i] = v
	}

	slice1[1] = 100 // ❸ slice1 요솟값 변경
	fmt.Println(slice1)
	fmt.Println(slice2)
}

/*
[1 100 3 4 5]
[1 2 3 4 5]
*/

copy() 함수를 사용해도 됩니다. copy()는 타겟 슬라이스, 원본 슬라이스 순서대로 인자를 넣고, 복사된 요소의 개수를 반환합니다.

package main

import "fmt"

func main() {
	slice1 := []int{1, 2, 3, 4, 5}
	slice2 := make([]int, 3, 10) // ❶ len:3, cap:10 슬라이스
	slice3 := make([]int, 10)    // ❷ len:10, cap:10 슬라이스

	cnt1 := copy(slice2, slice1) // ❸ slice1을 slice2에 복사합니다.
	cnt2 := copy(slice3, slice1) // ❹ slice1을 slice3에 복사합니다.

	fmt.Println(cnt1, slice2)
	fmt.Println(cnt2, slice3)
}

/*
3 [1 2 3]
5 [1 2 3 4 5 0 0 0 0 0]
*/

slice2는 len이 3이기 때문에 3개만 복사됩니다. copy()함수는 두 슬라이스의 길이 중 더 작은 값만큼의 요소를 복사합니다.

 

참고

Turker의 Go 언어 프로그래밍 18장 슬라이스 내용입니다.