[기초] Go 기초 정리 - 3 (Pointer, Struct, Array, Slice, Range, Map, Function value, Function Closure)

Tour of Go를 기반으로한 Go의 기본 내용입니다.

Pointers

• 포인터는 값의 메모리 주소를 가지고 있다.
• *T 타입은 T값을 가리키는 포인터이고 Zero value는 nil.

var p *int //p는 int값을 가리키는 포인터

• & 연산자는 해당 변수의 포인터(주소)를 생성.

i := 42 //int 타입 변수 i
p = &i //int 포인터 변수 p

• * 연산자는 포인터가 가리키는 주소의 값.
• C언어와는 다르게, Go에서는 포인터 산술을 지원하지 않음.

fmt.Println(*p) // 포인터 p를 통해 i 읽기
*p = 21 // 포인터 p를 통해 i에 값을 assign

 

Structs (구조체)

• 구조체는 필드의 집합체.

package main

import "fmt"

//struct 이름 : Vertex
//       필드 : X int, Y int
type Vertex struct {
	X int
	Y int
}

func main() {
    fmt.Println(Vertex{1, 2})
    
    v := Vertext{2, 3}
    //구조체 필드는 .(dot)으로 접근.
    v.X = 4 
    fmt.Println(v.X)
}

• 구조체 포인터를 통해서 구조체 필드를 접근할 수 있음.
• (*p).X 로 작성하면, 구조체 포인터 p에서 구조체의 X필드에 접근할 수 있음.
• 역참조할 필요 없이 p.X로 작성할 수 있음.

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	p := &v
	p.X = 1e9
	//(*p).X = 1e9
	fmt.Println(v)
}

• Struct Literal

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // Vertex 타입
	v2 = Vertex{X: 1}  // Y는 0으로 초기화
	v3 = Vertex{}      // X:0, Y:0
	p  = &Vertex{1, 2} // Vertex 포인터
)

func main() {
	fmt.Println(v1, p, v2, v3)
}

 

Arrays

• [n]T 타입은 타입이 T인 n개의 값들의 배열.

var a [10]int

 

package main

import "fmt"

func main() {
	var a [2]string
	a[0] = "Hello"
	a[1] = "World"
	fmt.Println(a[0], a[1])
	fmt.Println(a)

	primes := [6]int{2, 3, 5, 7, 11, 13}
	fmt.Println(primes)
}

 

Slices

• 배열은 고정된 크기를 가지고 있지만, 슬라이스는 배열의 요소들을 동적인 크기로, 유연하게 볼 수 있음.
• 슬라이스는 배열보다 훨씬 흔하게 쓰인다.
• []T 타입은 T타입을 원소로 가지는 슬라이스.

a[low : high] //low와 high-1까지의 인덱스를 범위로하는 slice
a[1:4] //1,2,3 index를 포함하는 범위

• 슬라이스는 기본 배열의 한 영역을 나타낸다.
• 슬라이스의 요소를 변경하면, 참조하는 배열의 해당 요소가 수정됨.
• 동일한 배열을 참조하는 다른 슬라이스는 이러한 변경사항을 볼 수 있음.

package main

import "fmt"

func main() {
	names := [4]string{
		"John",
		"Paul",
		"George",
		"Ringo",
	}
	fmt.Println(names)

	a := names[0:2]
	b := names[1:3]
	fmt.Println(a, b)

	b[0] = "XXX"
	fmt.Println(a, b) //names의 배열에서 변경됨.
	fmt.Println(names)
}

• 슬라이스 리터럴은 길이가 없는 배열 리터럴과 같음.

[3]bool{true, true, false} //배열 리터럴
[]bool{true, true, false} //슬라이스 리터럴

 

package main

import "fmt"

func main() {
	q := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(q)

	r := []bool{true, false, true, true, false, true}
	fmt.Println(len(r))

	s := []struct {
		i int
		b bool
	}{
		{2, true},
		{3, false},
		{5, true},
		{7, true},
		{11, false},
		{13, true},
	}
	fmt.Println(s)
}

• 슬라이스의 상한 또는 하한값을 생략하면, 슬라이싱할 때 기본값이 적용됨.
• 하한의 경우, 기본값은 0, 상한의 경우 슬라이스 길이가 적용.

var a [10]int
a[0:10]
a[:10]
a[0:]
a[:]

• 슬라이스는 길이(length)와 용량(capacity) 값을 가지고 있음.
• length는 슬라이스가 포함하는 요소의 개수.
• capacity는 슬라이스의 첫 번째 요소를 시작점으로 했을때의 참조하는 배열 요소의 개수.
  (start: 슬라이스의 시작점, end: 참조배열의 마지막 요소)

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	printSlice(s)

	// Slice the slice to give it zero length.
	s = s[:0]
	printSlice(s)

	// Extend its length.
	s = s[:4]
	printSlice(s)

	// Drop its first two values.
	s = s[2:]
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

/* Result
len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]
*/

• 슬라이스의 zero value는 nil 이며, 길이와 용량은 0이고 참조하는 배열은 없다.
• 슬라이스는 내장된 make함수로 생성가능.(동적 크기의 배열을 생성하는 방법)
• make함수는 0으로 이루어진 배열을 할당하며, 해당 배열을 참조하는 슬라이스를 반환.

a := make([]int, 5)  // len(a)=5

• 용량을 지정하려면 make 함수의 세번째 인자에 값을 전달.

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

• 슬라이스는 다른 슬라이스를 포함하여 모든 타입을 담을 수 있음.

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Create a tic-tac-toe board.
	board := [][]string{
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
	}

	// The players take turns.
	board[0][0] = "X"
	board[2][2] = "O"
	board[1][2] = "X"
	board[1][0] = "O"
	board[0][2] = "X"

	for i := 0; i < len(board); i++ {
		fmt.Printf("%s\n", strings.Join(board[i], " "))
	}
}

• 슬라이스에서 새로운 요소를 추가할 때는 append 함수를 사용할 수 있다.

func append(s []T, vs ...T) []T

• append의 첫번째 파라미터 s는 슬라이스의 타입 T
• 나머지 T값들은 슬라이스에 추가할 값들.
• append의 리턴 값은 원래 슬라이스의 모든 요소에 추가로 제공된 요소 값을 포함한 슬라이스이다.
• s의 원래 배열이 너무 작으면 더 큰 배열이 할당됨. 이 때 리턴되는 슬라이스는 새로 할당된 배열을 가리킨다.
  (Slice의 자세한 동작원리 보기)

package main

import "fmt"

func main() {
	var s []int
	printSlice(s)

	// append works on nil slices.
	s = append(s, 0)
	printSlice(s)

	// The slice grows as needed.
	s = append(s, 1)
	printSlice(s)

	// We can add more than one element at a time.
	s = append(s, 2, 3,4)
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

/*
len=0 cap=0 []
len=1 cap=1 [0]
len=2 cap=2 [0 1]
len=5 cap=6 [0 1 2 3 4]
*/

 

Range

• for에서 range는 슬라이스 또는 맵의 요소들을 순회함.
• 슬라이스에서 range를 사용하면, 각 순회마다 두 개의 값이 반환.
  첫 번째는 인덱스이고, 두 번째는 해당하는 값의 복사본.

package main

import "fmt"

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
	for i, v := range pow {
		fmt.Printf("2**%d = %d\n", i, v)
	}
}
/*
2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16
2**5 = 32
2**6 = 64
2**7 = 128
*/

• _을 할당하여 인덱스 또는 값을 건너뛸 수 있음.

for i, _ := range pow
for _, value := range pow

• 인덱스만 원하면, 두 번째 변수를 생략할 수 있음.

for i := range pow

 

package main

import "fmt"

func main() {
	pow := make([]int, 10)
	fmt.Println(pow)
	for i := range pow {
		pow[i] = 1 << uint(i) // == 2**i
	}
	for _, value := range pow {
		fmt.Printf("%d\n", value)
	}
}

 

Maps

• 맵은 키를 값에 매핑.
• 맵의 zero value는 nil.
• nil 맵은 키도 없고, 키를 추가할 수도 없다.
• make 함수는 주어진 타입의 초기화되고 메모리가 할당된 맵을 반환.

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m map[string]Vertex

func main() {
	m = make(map[string]Vertex)
	m["Bell Labs"] = Vertex{
		40.68433, -74.39967,
	}
	fmt.Println(m["Bell Labs"])
}

• 맵 리터럴은 구조체 리터럴과 동일하지만, 키가 필요.

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m = map[string]Vertex{
	"Bell Labs": Vertex{
		40.68433, -74.39967,
	},
	"Google": Vertex{
		37.42202, -122.08408,
	},
}

var c = map[int]Vertex{
	1: Vertex{
		40.68433, -74.39967,
	},
	2: Vertex{
		37.42202, -122.08408,
	},
}

func main() {
	fmt.Println(m)
	fmt.Println(c)
}

/*
map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]
map[1:{40.68433 -74.39967} 2:{37.42202 -122.08408}]
*/

 

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m = map[string]Vertex{
	"Bell Labs": {40.68433, -74.39967},
	"Google":    {37.42202, -122.08408},
}
var e = map[int]Vertex{
	1 : {20.999,-25.9999},
	2 : {1.222222, -24.434},
}
func main() {
	fmt.Println(m)
	fmt.Println(e)
}

 

Mutating Maps

• m 맵에 요소를 추가하거나 업데이트하기

m[key] = elem

• 요소 검색하기

elem = m[key]

• 요소 제거하기

delete(m, key)

• 두 개의 값을 할당하여 키가 존재하는지 테스트할 수 있음.
• key가 m안에 있다면, ok는 true. 없다면 false.

elem, ok = m[key]
elem, ok := m[key]//elem 또는 ok가 아직 선언되지 않았을 경우.

 

Function values (함수 값)

• 함수 값은 함수의 인수나 반환 값으로 사용될 수 있음.

package main

import (
	"fmt"
	"math"
)

func compute(fn func(float64, float64) float64) float64 {
	return fn(3, 4)
}

func main() {
	hypot := func(x, y float64) float64 {
		return math.Sqrt(x*x + y*y)
	}
	
	fu := func(x,y float64) float64 {
	
		return x+y
	}
	fmt.Println(hypot(5, 12))
	fmt.Println(compute(fu))
	fmt.Println(compute(hypot))
	fmt.Println(compute(math.Pow))
}

 

Function closures

• Go 함수들은 클로저일 수 있음.
• 클로저는 함수의 외부로부터 오는 변수를 참조하는 함수 값.
  이러한 의미에서 함수는 변수에 "bound"됨.

package main

import "fmt"

func adder() func(int) int {
	sum := 0 
    //각 클로저는 그 자체의 sum 변수에 bound
	return func(x int) int {
		sum += x 
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}
/*
0 0
1 -2
3 -6
6 -12
10 -20
15 -30
21 -42
28 -56
36 -72
45 -90
*/