[Go] go-tour _ moretypes n/27 수정 중

해당글은 아래 내용을 바탕으로 공부한 내용들을 정리한 글 입니다.

Go를 향한 여행

---

Pointers

package main

import "fmt"

func main() {
	i, j := 42, 2701

	p := &i         // point to i
	fmt.Println(*p) // read i through the pointer
	*p = 21         // set i through the pointer
	fmt.Println(i)  // see the new value of i

	p = &j         // point to j
	*p = *p / 37   // divide j through the pointer
	fmt.Println(j) // see the new value of j
}

c언어의 포인트와 완전히 똑같은 형식으로 동작하고 사용할 수 있다.

---

Structs

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	fmt.Println(Vertex{1, 2})
}

구조체 역시 c언어의 구조체와 동일하고 동작하고 사용 가능

초기값을 X = 1, Y = 2로 넣겠다는 의미

 

문법이 비슷해서 편하다 ㅎㅎ

---

Struct Fields

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	fmt.Println(v.X)
	v.X = 4
	fmt.Println(v.X)
}

구조체를 선언할 경우

v := Vertex{1, 2} 형식으로 초기 값을 넣어주거나

v := Vertex{} 형식으로 선언을 해줘야 사용할 수 있다.

물론 구조체안에 변수들도 값을 수정할 수 있다.

---

Pointers to structs

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

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

포인터와 구조체를 연결하여 사용할 수 있다.

당연한 이야기.

---

Struct Literals

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // has type Vertex
	v2 = Vertex{X: 1}  // Y:0 is implicit
	v3 = Vertex{}      // X:0 and Y:0
	p  = &Vertex{1, 2} // has type *Vertex
)

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

v1 : 가장 기본적으로 x와 y값을 모두 넣어준 경우.

v2 : x에 값만 1이라고 선언을 해주고 y의 값은 추가적으로 건들여주지않았으니, y는 default인 0이 들어가게 된다.

v3 : 아무것도 명시해주지않은 경우에는 모두 default인 0이 들어간다.

p : p에 경우에는 포인터 값으로 주소값을 넣어준 경우이다. 그래서 출력을 해보면 & 주소값 표시가 붙어서 나오게 된다.

---

Arrays

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)
}

기본적인 배열을 사용하는 방법과 예시 등을 보여준다.

배열의 길이에 경우에는 타입의 일부라서 조정하거나 바꿀 수 없다! 고정된 값

c언어와 다른점이 없어서 똑같이 사용 가능.

---

Slices

package main

import "fmt"

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

	var s []int = primes[1:4]
	fmt.Println(s)
}

배열과는 조금 다르게 유동적으로 값을 사용할 수 있다.

원하면 값을 추가하거나 지우는 형식으로 길이를 조정해가며 사용할 수 있다.

 

go에 경우에는 배열보다는 슬라이스를 조금 더 흔하고 자주 사용한다고 한다.

---

Slices are like references to arrays

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"
	names[0] = "hello"
	fmt.Println(a, b)
	fmt.Println(names)
}

슬라이스가 배열을 참조하여 생성이 된 경우에는 모든 값들이 서로 공유되고 

슬라이스에 요소를 수정하거나 배열에 값을 수정하면

그 값이 전체에도 영향을 주어 참조하는 모든 값들이 바뀌게 된다.

---

Slice literals

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(r)

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

 

슬라이스 리터럴은 길이가 없는 배열 리터럴이라고 한다.

위와 같이 [] 형식으로 값을 주지않으면 원하는 만큼 선언이 가능하고

슬라이스를 만들 때 struct를 사용하면 구조체와 같이 한번에 여러개의 다른 타입 인자를 넣은 형식처럼 구현할 수 있다.

 

진짜 편하겠다라고 느낀 부분

메모리 부분이나 속도부분에서는 어떻게 돌아갈지는 잘 모르겠으나, 편함 하나정도는 인정!

---

Slice defaults

package main

import "fmt"

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

	s = s[1:4]
	fmt.Println(s)

	s = s[:2]
	fmt.Println(s)

	s = s[1:]
	fmt.Println(s)
}

슬라이스를 출력하고 값을 수정하는 여러가지 방법들 정리

상한이나 하한의 따라서 어떻게 값을 줄 수 있고 수정할 수 있는지

python처럼 같은 형식으로 동작을 한다.

상한이나 하한을 비워두는 경우 값이 처음이나 끝까지라는 식으로 해석이 되게 된다.

상한에 경우 상한 값까지 담기는 것이 아닌 상한 -1 까지 담기가 된다.

---

Slice length and capacity 

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)
}

len : 문자가 몇개 담겨 있는지 반환해주는 슬라이스에 길이 ( 문자가 담겨있는 개수 )

cap : 슬라이스의 용량 ( malloc 처럼 사용할 수 있는 범위 공간 )

len의 길이가 cap를 넘어선 경우에는 cap는 2배의 값으로 증감 된다.

ex) 6.. 12.. 24 

 

중간에 s[:0] 형식으로 값을 모두 날려도 s[:4]로 다시 접근할 수 있는 이유는

cap이라는 메모리 공간에서 이전에 할당이된 값을 기억한다고 한다. 그래서 len을 날려버리고 다시 재 선언해도 기존 값이 유지될 수 있다.

 

메모리공간을 최대한 효율적으로 사용하기 위해서 어떻게 해야하는지 고민한 결과물이라고 생각한다

cap 자체를 크게 줘버렸다면 쓸데없이 메모리를 많이 쓰게되기 때문에 효율성을 생각해서 그렇게 작성했다고 생각.

---

Nil slices

package main

import "fmt"

func main() {
	var s []int
	fmt.Println(s, len(s), cap(s))
	if s == nil {
		fmt.Println("nil!")
	}
}

아무런 값도 할당하지않은 경우에는 nil 이다.

make를 사용해서 할당하거나 값을 넣지않은 경우에는 공간 차지 X

---

Creating a slice with make

package main

import "fmt"

func main() {
	a := make([]int, 5)
	printSlice("a", a)

	b := make([]int, 0, 5)
	printSlice("b", b)

	c := b[:2]
	printSlice("c", c)

	d := c[2:5]
	printSlice("d", d)
}

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

make함수를 사용하는 기본적인 튜토리얼

len에 대한 길이를 주지않게 되면 모두 0으로 들어가게 되고

len에 대한 길이를 주게 되면 위와 같이 cap는 5인데 len은 0인 모습을 볼 수 있다.

---

Slices of slices

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], " "))
	}
}

슬라이스에는 int형만 담을 수 있는 것이 아니라 string float 등등 다양한 타입들을 담을 수 있다.

+ 2차원 슬라이스 선언 방법

---

Appending to a 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)
}

append를 통해서 슬라이스에 값을 추가 할 수 있다.

"append 의 첫번째 파라미터 s 는 슬라이스의 타입 T 입니다. 그리고 나머지 T 값들은 슬라이스에 추가할 값들입니다."

---

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)
	}
}

range 슬라이스의 요소를 순회할 수 있다.

python의 range와 같이 사용 가능하다.

 

히히 짱 좋아

---

Range continued

package main

import "fmt"

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

기본적으로 

for i, value := range pow

형식으로 인덱스와 value 값을 받아서 사용할 수 있지만

for _, value := range pow

형식으로 하면 값을 건너 뛸 수 있다.

for i := range pow

인덱스가 우선 순위로 되어 i에는 인덱스가 담긴다.

---

Exercise: Slices

package main

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
	ss := make([][]uint8, dy)
	for y := 0; y < dy; y++ {
		s := make([]uint8, dx)
		for x := 0; x < dx; x++ {
			s[x] = uint8((x + y) / 2)
			// s[x] = uint8(x * y)
			// s[x] = uint8(x ^ y)
		}
		ss[y] = s
	}
	return ss
}

func main() {
	pic.Show(Pic)
}

(x+y)/2  ,  x*y  ,   x^y  

pic.Show라는 함수를 실행하면 위와값이 값에 따라서 그림을 그려준다.

slice를 실제로 사용해봐라? 라는 의미

---

Maps

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"])
}

map : key를 가지고 해당하는 value를 빠르게 찾을 수 있는 해시테이블을 구현한 구조

---