Go의 포인터

Go는 값에 의한 호출 언어입니다. 즉, 함수 호출에서 각 함수 인수의 복사본을 사용합니다. 변수를 업데이트하려면 포인터를 사용하여 주소를 전달해야 합니다.

Go 포인터 구문은 C와 유사합니다.

포인터 기본& 연산자를 사용하여 변수의 주소 가져오기
포인터를 사용한 역참조* 연산자

// int variable
year := 2020
// we can get address using & op
year_add := &year
fmt.Println("Val of year: ", year)
fmt.Println("Address of year: ", &year)
fmt.Println("Val of year using pointer: ", *(&year))

값에 의한 함수 호출

func call_by_val(year int) {
  year = year + 1
}
call_by_val(year)
// year won't be updated as it uses a copy in call_by_val function
fmt.Println("Call by val res: ", year)

참조에 의한 함수 호출

func call_by_ref(year *int) {
  *year = *year + 1
}
call_by_ref(&year)
// here it will update the variable as we pass the address of the variable
fmt.Println("Call by ref res: ", year)

포인터 수신기가 있는 메서드
메서드에서 포인터 수신기를 사용할 때 Go 컴파일러는 수신기 인수의 유형을 수신기 매개변수와 일치시키기 위해 암시적 변환을 수행합니다.
다른 사용 사례를 설명하기 위해 다음과 같이 Point 유형과 몇 가지 방법을 사용할 것입니다.

type Point struct {
  X, Y int
}
func (p *Point) Scale(factor int) {
  p.X = p.X * factor
  p.Y = p.Y * factor
}
// pointer receiver param
func (p *Point) Print() {
  fmt.Println("X: ", p.X, ", Y: ", p.Y)
}

// receiver param of type Point, any change won't be reflected on receiver argument
func (p Point) ScaleVal(factor int) {
  p.X = p.X * factor
  p.Y = p.Y * factor
}

// value receiver param
func (p Point) PrintP() {
  fmt.Println("X: ", p.X, ", Y: ", p.Y)
}

사용 사례 1: 둘 다 동일한 포인터 유형을 사용합니다.
암시적 변환 없음

p := Point{X:2, Y:3}
p_ptr := &p
Scale(p_ptr, 2)
// this will print the scaled point
Print(p_ptr)

사용 사례 2: 수신자 매개변수가 포인터 유형입니다.

// receiver arg is of type Point, compiler implicitly get &p to match type with receiver param
p.Scale(2)
p.Print()

사용자 사례 3: 수신자 인수가 포인터 유형입니다.

// receiver param is of type Point but receiver arg is a pointer, compiler dereference the receiver but any mutation won't be reflected on receiver arg
p_ptr.ScaleVal(2)
p_ptr.PrintP()

다음은 repl.it의 전체 예입니다.