Go (by notepad) - HiroSung/Study GitHub Wiki
[Go Programming]
7/2. 804ํธ / ๊น๋ณ์ง.์๋์คํ ๊ฐ์ฌ
. ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก .
- ไธญ ์ ์ ์ธ์ด์ธ Go
- cf ) python : ๋์ ์ธ์ด. H/W๊ฐ ์ข๊ธฐ๋๋ฌธ์ ํ์ ๋ฐ์ดํฐ ์ถ๋ ฅ์ด ๋นจ๋ผ์ง.
I. Go ์ธ์ด ์๊ฐ ๋ฐ ํ๊ฒฝ
- https://golang.org/doc/
- Go ํน์ฑ
. ์ปดํ์ผ ์ธ์ด > ์ปดํ์ผ(๋ฌธ๋ฒ๊ฒ์ฌ์ ์ํํ ์ ์๋ ์ ๋จ๊ณ๊น์ง ๋ง๋ค์ด์ฃผ๋) ํ๋ก๊ทธ๋จ์ด ๋ณ๋๋ก ํ์ํจ. ์ปดํ์ผ ํ๊ณ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ ค์ ์ํ.
. ์์คํ
ํ๋ก๊ทธ๋๋ฐ์ ์ํด ๊ฐ๋ฐ
. C++, Java, Python์ ์ฅ์ .
. GC ๊ธฐ๋ฅ ์ ๊ณต
. 25๊ฐ ํค์๋๋ก ํ๋ก๊ทธ๋๋ฐ ๊ฐ๋ฅ.
. * CSP ์คํ์ผ์ Concurrent ํ๋ก๊ทธ๋๋ฐ ์ง์โฆ Thread ์ฒ๋ฆฌ. ์ฒ๋ฆฌ๋ฐ์ดํฐ ๊ณต์
- Go ์ค์น ๋ฐ ์คํ
. https://golang.org/dl/
. 1.10.3 : why? ์ฒซ๋ฒ์งธ๋ ์ฃผ๋ฒ์ .์๋ธ๋ฒ์ ผ(๊ธฐ๋ฅ์ถ๊ฐ).๋น๋๋ฒ์ ผ(ํด.์ปดํ์ผ๋ฌ๋ก์์ค์ ๋ฌธ์ ๊ฐ ์์ ๊ฒฝ์ฐ ์ฌ๋ฆผ)
. โฆmsi๋ก ์ค์นํ๋ฉด ์ข์ง๋ง ์์
ํด๋๋ ๋ง๋ค๊ณ ATOM ์ค์นํ์ฌ ์ฌ์ฉํ๋ฉด ์ข์.
. ATOM ์ค์น : https://atom.io/ (๋๋ Visual Studio Code๋ ๊ฐ๋ฅ)
https://git-scm.com/downloads ์์ git์ ๋ค์ด๋ก๋ํ์ฌ ์ค์นํ๋ฉด
workspace ๋ฅผ C:\goApp๋ก ์ง์ ํจ
Go Programming์ ์ฐ๊ฒฐ๋ ์ github๋ฅผ ์ฌ์ฉํ ์ ์์ด ์ฉ์ดํจ.
cf) ATOM ์ฌ์ฉ๋ฐฉ๋ฒ : https://seoulrain.net/2016/12/05/atomeditor/
. ์ํ๋ฐฉ๋ฒ
# go run test.go > ์ปดํ์ผ
# go build test.go > ๋น๋
. Workspace ํด๋
. C:\GoApp ํด๋๋ก ์ ํ๋ค๋ฉด bin, src , pkg ํด๋๊ฐ ์์ด์ผ ํจ.
- ํ๋ก๊ทธ๋๋ฐ์ ์ ์ฅ์์ ์ด๋ฆ
. ๋ณ์
. GO๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ์ ์ ์ฅํ๋ ๋ฐฉ์
. ๋ฉ๋ชจ๋ฆฌ์ ๊ฐ์ ์ ์ฅํ๋ ๋ํ์ ์ธ ์ด๋ฆ : ๋ณ์
. var๋ก ์ ์ธ
var a int
var f float32 = 11.
. ์์
. ํ๋ฒ ์ ์ฅํ๋ฉด ๋ณ๊ฒฝ ๋ถ๊ฐ
. const ์ฌ์ฉํ์ฌ ์ ์ธ
const C int = 10
const S string = โHiโ
. Go ํค์๋(์์ฝ์ด) โ ๊ต์ฌ P51 ์ฐธ๊ณ
II. ๋ฐ์ดํฐ ํ์
๊ณผ ๋ฌธ๋ฒ
# Go ํ๋ก๊ทธ๋๋ฐ์ ๋ฐ์ดํฐ ํ์
- ์ ์ PGM์ ํ์์ ์ด์ํ!
. ์ ์
. ์์์
. ๋ฌธ
- ํ์
(ํ์)
. ์ฐธ/๊ฑฐ์ง(Boolean) : bool (๋ด๋ถ์ ์ผ๋ก๋ ์ซ์๋ก ์ฒ๋ฆฌ)
. ๋ฌธ์์ด : string
. ์ ์ํ ํ์
: ์ซ์ โ int int8 int16 int32 int64 uintโฆ
. ์ค์ํ : ์์์ โ float32 float64 complex64 complex128
. ๊ธฐํ : byte (uint8๊ณผ ๋์ผ. ๋ฐ์ดํฐ ์ฃผ๊ณ ๋ฐ๊ณ ํ์ผ ์
์ถ๋ ฅ์ ์ฌ์ฉ), rune (int32์ ๋์ผ)
# ๋ฌธ์์ด
- ๋ฌธ์์ด ๋ฆฌํฐ๋ด
. ์ค์ ๋ฐ์ดํฐ
. Black Quote : โโ โ Raw String ๊ทธ๋๋ก์ด ๊ฐ
. Double Quote : "" โ ๋ณต์ ๋ผ์ธ์ ๊ฑธ์ณ ์ธ ์ ์์. ์ธ์ฉ๋ถํธ ์์ด Escape ๋ฌธ์์ด ๋ค์ ํน๋ณํ ์ด๋ฏธ๋ก ํด์. ๋ฌธ์์ด์ \n์ด ์์ผ๋ฉด New Line์ผ๋ก ์ธ์
# ํ๋ณํ
- ๋ฐ์ดํฐ ํ์
์ ๋ณํ
- ํ์๋ณํฉ/ํ์๋ณํ
- ํ๋์ ๋ฐ์ดํฐ ํ์
์์ ๋ค๋ฅธ ๋ฐ์ดํฐ ํ์
์ผ๋ก ๋ณํํ๊ธฐ ์ํด์๋ T(v)์ ๊ฐ์ด ํํ
. T๋ ๋ณํํ๊ณ ์ ํ๋ ํ์
์ ํ์ํ๊ณ , v๋ ๋ณํ๋ ๊ฐ์ ์ง์ ํ ๊ฒ.
. Go์์ ํ์
๊ฐ ๋ณํ์ ๋ช
์์ ์ผ๋ก ์ง์ *
. ๋ช
์์ ์ง์ ์ด ์์ด ๋ณํ์ด ์ผ์ด๋๋ฉด ๋ฐํ์ ์๋ฌ๊ฐ ๋ฐ์
# ํ๋ก๊ทธ๋๋ฐ ์ฐ์ฐ์
- ๋ฐ์ดํฐ์ ์ ์ ์์
: ์ฐ์ฐ
- ์ฐ์ ์ฐ์ฐ์
- ๊ด๊ณ์ฐ์ฐ์
- ๋
ผ๋ฆฌ์ฐ์ฐ์
- Bitwise์ฐ์ฐ์
. ๋นํธ๋จ์ ์ฐ์ฐ์ ์ํด ์ฌ์ฉ. ๋ฐ์ด๋๋ฆฌ AND, OR, XOR์ ๋ฐ์ด๋๋ฆฌ ์ฌํํธ ์ฐ์ฐ์
. & , | , ! , << , >>
- ํ ๋น ์ฐ์ฐ์
. ๊ฐ์ ํ ๋นํ๋ = ์ฐ์ฐ์ ์ธ์ ์ฌ์น์ฐ์ฐ, ๋นํธ์ฌ๋์ ์ถ์ฝํ =, &=, <<= ๊ฐ์ ์ฐ์ฐ์
- ํฌ์ธํฐ ์ฐ์ฐ์ (ํจ์ ํ ๋ ์ฌ์ฉ)
. C+์ ๊ฐ์ด & ํน์ * ์ ์ฌ์ฉํ์ฌ ํด๋น ๋ณ์์ ์ฃผ์๋ฅผ ์ป์ด๋ด๊ฑฐ๋ ์ด๋ฅผ ๋ฐ๋๋ก Dereferenceํ ๋ ์ฌ์ฉ
. ํฌ์ธํฐ์ฐ์ฐ์๋ฅผ ์ ๊ณตํ์ง๋ง ํฌ์ธํฐ ์ฐ์ถ ์ฆ ํฌ์ธํฐ์ ๋ํ๊ณ ๋นผ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํ์ง ์์.
# ํ๋ก๊ทธ๋จ์ ์ ์ด โ ์กฐ๊ฑด๋ฌธ
- ๊ฐ๋ฐ์ ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ์ ์ด
- if
. ๋ฐ๋์ ์กฐ๊ฑด ๋ธ๋ญ ์์ ๋ธ๋ ์ด์ค({)๋ฅผ if ๋ฌธ๊ณผ ๊ฐ์ ๋ผ์ธ
. ์กฐ๊ฑด์์ ๋ฐ๋์ Boolean ์์ผ๋ก ํํ
- switch
. ์ฌ๋ฌ ๊ฐ์ ๋น๊ตํด์ผ ํ๋ ๊ฒฝ์ฐ
. ๋ค์์ ์กฐ๊ฑด์์ ์ฒดํฌํด์ผ ํ๋ ๊ฒฝ์ฐ
. switch๋ฌธ ๋ค์ ํ๋์ ๋ณ์(ํน์ Expression)๋ฅผ ์ง์
. case ๋ฌธ์ ํด๋น ๋ณ์๊ฐ ๊ฐ์ง ์ ์๋ ๊ฐ์ ์ง์ ํ์ฌ, ๊ฐ ๊ฒฝ์ฐ์ ๋ค๋ฅธ ๋ฌธ์ฅ ๋ธ๋ญ๋ค์ ์ง์ .
. switch ์ฉ๋ฒ
- switch ๋ค์ Expression์ด ์์ ์ ์์.
- case๋ฌธ์ Expression์ ์ธ ์ ์์.
- No default fall through
- Type switch
# ํ๋ก๊ทธ๋จ์ ์ ์ด โ ๋ฐ๋ณต๋ฌธ
- ํน์ ์ฝ๋๋ฅผ ๋ฐ๋ณตํ ๊ฒฝ์ฐ
. for ๊ตฌ๋ฌธ์ด ์ผ๋ฐ์
. Go๋ for ๊ตฌ๋ฌธ ํ๋๋ง ์กด์ฌ
. โfor ์ด๊ธฐ๊ฐ; ์กฐ๊ฑด์; ์ฆ๊ฐ {โฆ}โ์ ํ์ ์ฌ์ฉ
package mainfunc main() {
sum := 0
for i := 1; i <= 100;i++ {
sum += 1
}println(sum)
}
- for range ๊ตฌ๋ฌธ
. ์ปฌ๋ ์ ์ผ๋ก ๋ถํฐ ํ ์์์ฉ ๊ฐ์ ธ์ ์ฐจ๋ก๋ก for ๋ธ๋ญ์ ๋ฌธ์๋ค์ ์คํ.
. foreach ๋น์ทํ ์ฉ๋ฒ for ์ธ๋ฑ์ค, ์์๊ฐ := range ์ปฌ๋ ์ " ๊ฐ์ด for ๋ฃจํ๋ฅผ ๊ตฌ์ฑ
name := []string{"ํ๊ธธ๋", โ์ด์์ โ, "๊ฐ๊ฐ์ฐฌ"}
for index, name := range names {
println(index, name)
}
- ๊ธฐํ ์ ์ด๋ฌธ
. break
. continue
. goto : ์ต๋ํ ์์ ํด์ผ ํจ.
- ์ค์ต
. ์ฝ๋ฉ์ ์ค์ฒฉ์ ์ค์ฒฉ์ ์ง์ํด์ผ ํ๋ค.
III. ํจ์์ ์ปฌ๋ ์
1. ํจ์๋?
โ ์ฌ๋ฌ ๋ฌธ์ฅ์ ๋ฌถ์ด์ ์คํํ๋ ์ฝ๋ ๋ธ๋ญ์ ๋จ์. func ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ์
- func ๋ค์ ํจ์๋ช
์ ์ ๊ณ ๊ดํธ()์์ ๊ทธ ํจ์์ ์ ๋ฌํ๋ ํ๋ผ๋ฏธํฐ
โ Pass By XXXXXX
. ํ๋ผ๋ฏธํฐ๋ฅผ ์ ๋ฌํ๋ ๋ฐฉ์์ ํฌ๊ฒ Pass By Value์ Pass By Reference
. Pass By Value
+ ๊ฐ ๋ง ์ ๋ฌ
+ ํธ์ถํ๊ธฐ ์ ํจ์์ ๊ฐ๋ง ๊ทธ๋๋ก ์ ๋ฌ
+ ์๋ณธ ํจ์์ ๊ฐ์ ๋ณ๊ฒฝ๋์ง ์์.
. Pass By Reference
+ ์ฐธ์กฐ ์ ๋ฌ. ๋ฐ์๋๋ *, ์ ๋ฌํ ๋๋ & ๊ธฐํธ ์ฌ์ฉ.
+ ํธ์ถํจ์์์ ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด ์๋ณธ ํจ์๋ ๊ฐ์ด ๋ณ๊ฒฝ๋จ.
package main
func main() {
msg := โHelloโ
say(&msg)
println(msg) // ๋ณ๊ฒฝ๋ ๋ฉ์์ง ์ถ๋ ฅ
}
func say(msg string) {
println(msg)
*msg = โChangedโ // ๋ฉ์์ง ๋ณ๊ฒฝ
}
- ๊ฐ๋ณ์ธ์ ํจ์
* ๊ณ ์ ๋ ์์ ํ๋ผ๋ฏธํฐ๋ค์ ์ ๋ฌํ์ง ์๊ณ ๋ค์ํ ์ซ์์ ํ๋ผ๋ฏธํฐ๋ฅผ ์ ๋ฌํ๊ณ ์ ํ ๋
+ ๊ฐ๋ณ ํ๋ผ๋ฏธํฐ๋ โฆ ์ผ๋ก ํํ
- ํจ์ ๋ฆฌํด๊ฐ
* ํจ์๋ ๋ฆฌํด๊ฐ์ด ์
์ ์๋, ๋ฆฌํด๊ฐ์ด ํ๋ ์ผ ์๋ ๋๋ ๋ฆฌํด๊ฐ์ด ๋ณผ์ ๊ฐ์ผ ๊ฐ๋ฅ์ฑ
- * ์ต๋ช
ํจ์
* ํจ์๋ช
์ ๊ฐ์ง ์๋ ํจ์๋ฅผ ์ต๋ช
ํจ์(Anonymous Function)
*
main() {
sum := func( n โฆint) int {
s := 0
for _, i := range n {
s += i
}
turn s
}
s := sum(1, 2, 3, , 4, 5)
}
- ์ผ๊ธํจ์
* ํจ์์ ์
๋ ฅ ํ๋ผ๋ฏธํฐ๋ ๋ฆฌํด ํ๋ผ๋ฏธํฐ๋ก์ ํจ์ ์์ฒด๊ฐ ์ฌ์ฉ
* ํจ์๋ฅผ ๋ค๋ฅธ ํจ์์ ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌํ๋ ๋ฐฉ๋ฒ
func main() {
//๋ณ์ add์ ์ต๋ช
ํจ์ ํ ๋น
add := func(i int, j int) int {
return i + j
}
// add ํจ์ ์ ๋ฌ
r1 := calc(add, 10, 20)
println(r1) // 30
// ์ง์ ์ฒซ๋ฒ์งธ ํ๋ผ๋ฏธํฐ์ ์ต๋ช
ํจ์๋ฅผ ์ ์ํจ
r2 := calc( func(x int, y int) int { return x โ y}, 10, 20)
println(r2) // -10
}
func calc(f func(int, int) int, a int, b int) int {
result := f(a, b)
return result
}
- * type๋ฌธ์ ์ฌ์ฉํ ํจ์ ์ํ์ ์ ์
* type๋ฌธ์ ๊ตฌ์กฐ์ฒด(struct), ์ธํฐํ์ด์ค ๋ฑ Custom Type(ํน์ User Defined Tpye)์ ์ ์ํใ
ฃ ์ํด ์ฌ์ฉ
* ๋์์ ์ฌ๋ฌ๊ฐ์ ํจ์๋ฅผ ์ํํ๊ณ ์ ํ๋ ๊ฒฝ์ฐ ์ํํจ. (deligate! = ์ต๋ช
ํจ์+์ผ๋ช
ํจ์)
// ์ํ ์ ์
type calculator func(int, int) int
// calculator ์ํ ์ฌ์ฉ
func calc(f calculator, a int, b int) int {
result := f(a, b)
return result
}
- * ํด๋ก์ . ์ค์ฒฉํจ์
* ํจ์ ๋ฐ๊นฅ์ ์๋ ๋ณ์๋ฅผ ์ฐธ์กฐํ๋ ํจ์๊ฐ
func nextValue() func() int {
i := 0
return func() int {
i++
return i
}
}
func main() {
next := nextValue()
println(next()) // 1
println(next()) // 2
anotherNext = nextValue()
println(anotherNext()) // 1 ๋ถํฐ ๋ค์ ์์
}
- ์ค์ต
* format string โฆ ๋ ์๋ฅผ ๋
/์/์ผ ๋ก ์ถ๋ ฅํ ๋ ์ฌ์ฉํจ.
- ์ปฌ๋ ์
+ ๋ฐฐ์ด
- ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋์ผํ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ์์์ ์ผ๋ก ์ ์ฅํ๋ ์๋ฃ ๊ตฌ์กฐ.
- ๋ฐฐ์ด์ ์ต๋ํ ๊ฐ๋จํ๊ฒ ๊ตฌ์ฑ.
var ๋ณ์๋ช
[๋ฐฐ์ดํฌ๊ธฐ] ๋ฐ์ดํฐํ์
// ๋ฐฐ์ดํฌ๊ธฐ โ indexer
- ๋ฐฐ์ด์ ์ด๊ธฐํ
var a1 = 3 int{1,2,3}
var a3 = [โฆ] int {1,2,3,4}
- ๋ค์ฐจ์ ๋ฐฐ์ด : 3์ฐจ์ ๊น์ง ์ฌ์ฉ์ ๊ถ์ฅ
var multiArray 345int //์ ์
multiArray012 = 10 // ์ฌ์ฉ
+ ์ฌ๋ผ์ด์ค
- ์ผ์ฐจ์๊ฐ๋ณ๋ฐฐ์ด. ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ๋ ์ ์์.
- ๋ฐฐ์ด์ ๊ณ ์ ๋ ๋ฐฐ์ดํฌ๊ธฐ ์์ ๋์ผํ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ์ฐ์์ ์ผ๋ก ์ ์ฅ
- ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋์ ์ผ๋ก ์ฆ๊ฐ์ํค๊ฑฐ๋ ๋ถ๋ถ์ ๋ฐ์ทํ๋ ๋ฑ์ ๊ธฐ๋ฅ (cf. linked Database ๊ตฌ์กฐ)
var a []int
a = []int{1,2,3}
a1 = 10
- ์ฌ๋ผ์ด์ค ์ถ๊ฐ/๋ณํฉ/๋ณต์ฌ
+ copy(), append() ์ฌ์ฉ
+ Map
- Key์ Value์ ๊ตฌ์กฐ : ํด์ํ
์ด๋ธ(Hash table)
tickers := map[string]string{
โGOOGโ: โGoogle Incโ,
โMSFTโ: โMicrosoftโ,
โFBโ: โFace Bookโ,
}
IV. ํจํค์ง์ ๊ตฌ์กฐ์ฒด
1. ํจํค์ง
- ์ฝ๋์ ๋ชจ๋ํ, ์ฝ๋์ ์ฌ์ฌ์ฉ ๊ธฐ๋ฅ์ ์ ๊ณต
- ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํจํค์ง๋ค์ GOROOT/pkg ์์ ์กด์ฌ
- Main ํจํค์ง
+ main ์ด๋ผ๊ณ ๋ช
๋ช
๋ ํจํค์ง๋ Go Compiler์ ์ํด ํน๋ณํ๊ฒ ์ธ์
+ ๊ณต์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ๋ง๋ค ๋์๋ , main ํจํค์ง๋ main ํจ์๋ฅผ ์ฌ์ฉํด์๋ ๋ถ๊ฐ
- Import
+ ๋ณต์ ๊ฐ์ผ ๊ฒฝ์ฐ ์ธ๋ฏธ์ฝ๋ก (์๋์ฐ์ฆ์ ๊ฒฝ์ฐ)์ ์ฌ์ฉํ์ฌ ์ฐ๊ฒฐ
- ํจํค์ง init ํจ์/alias
+ ํจํค์ง ์คํ์ ์ฒ์์ผ๋ก ํธ์ถ๋๋ init() ํจ์
+ import์ alias ์ ์ ๊ฐ๋ฅ
- ์ฌ์ฉ์ ์ ์ ํจํค์ง ์์ฑ / Export
+
package testlib
import โfmtโ
var pop = map[string]string // ํ๋. ํจํค์ง์ ํจ์์ฌ์ด์ ์๊ธฐ์ ์ฌ์ฉ์ ๋ฐ๋ผ ๋ณ๊ฒฝ ๊ฐ๋ฅํจ. ์์ ํด์ผ ํจ.
func init() {
pop = make(map[string]string)
pop[โAdelโ] = โHelloโ
}
func getMusic(singer string) string {
return pop[singer]
}
2. ๊ตฌ์กฐ์ฒด
- ์ฌ์ฉ์ ์ ์ ๋ฐ์ดํฐํ์
๋ง๋ค๋ ์ฌ์ฉ
- ํ๋ ๋ฐ์ดํฐ๋ง์ ๊ฐ์ง๋ฉฐ, (ํ์๋ฅผ ํํํ๋) ๋ฉ์๋๋ ์์. OOP์ ๊ณต์ ์ ๋ฐฉ์์ผ๋ก ์ง์
- Method์์ ๋ค์ ํ๋ฒ ์ค๋ช
์์
- ๊ตฌ์กฐ์ฒด์ ์ ์ธ
type person struct {
name string
age int
}
func main() {
p := person{}
p.name = โLeeโ
p.age = 10
}
- ๊ฐ์ฒด์ ์์ฑ
var p1 person
p1 = person{"bob", 20}
p2 := person{name:โSeanโ, age:50}
- ๊ฐ์ฒด : ์์๊ณผ ๋ค์์ฑ ๊ธฐ๋ฅ์ ํตํด์ ๊ธฐ๋ฅ์ ๋ฐ๊ฟ ์ ์์. / ์ ๋ณด์๋ public, private, protected
- ์์ฑ์ ํจ์
+ Constructor : ํ๋ ์ ์ฒด๊ฐ ์ฌ์ฉ๋๊ธฐ ์ ์ ์ด๊ธฐํ ๋์ด์ผ ํ๋ ๊ฒฝ์ฐ ์ฌ์ฉ.
+ ๋ชจ๋ ๊ฒ์ ๊ฐ๊ณ ์ํ๋๋ ํจ์. ์๋ชป ๊ตฌ์ฑํ๋ฉด ์ฒ์ ์ํ์ ์ํ์ด ์๋ ์ ์์. ํ์ํ ๋๋ง ์ฌ์ฉํ๊ธฐ๋ฅผ~
type dict struct {
data map[int]string
}
//์์ฑ์ ํจ์ ์ ์
func newDict() *dict {
d := dict{}
d.data = map[int]strig{}
return &d // ํฌ์ธํฐ ์ ๋ฌ
}
func main() {
dic := newDict() // ์์ฑ์ ํธ์ถ
dic.data1 = โaโ
}
2์ผ์ฐจ
V. ๋ฉ์๋์ ์ธํฐํ์ด์ค
VI. ์๋ฌ์ฒ๋ฆฌ์ ์ง์ฐ ์คํ๊ณผ ํจ์
VII. ๋์์ฑ(thread) ๋ฐ ๋ฃจํด๊ณผ ์ฑ๋ (* ์ค์)
VIII. ํ์ผ ์ฝ๊ธฐ/์ฐ๊ธฐ์ ํ ์คํธ F/W(*์ค์)