Go언어 입문 #2

연산자

• 비트 연산자 : &, |, ^(같0다1), &^(비트 클리어 : 우변bit반전->&)

• 시프트 연산자 : <<(n비트 왼쪽으로), >>(n비트 오른쪽으로)

• 실수오차, Nextafter()

package main
import (
	"fmt"
    "math"
)
func equal(a, b float64) bool {
	return math.Nextafter(a,b) == b
}

func main() {
	var a float64 = 0.1
    var b float64 = 0.2
    var c float64 = 0.3
    
    fmt.Printf("%0.18f == %0.18f : %v\n", c, a+b, equal(a+b,c))
}  //true - Nextafter()가 실수의 근소한 오차를 처리해준다

• 대입 연산자 : 하나의 대입 연산자로 여러 값을 대입할 수 있음
  a, b = 3, 4
• 값 교환 : a, b = b, a b값이 a로, a값이 b로.

---

함수

Go는 C와는 다르게 같은 패키지 내에 있으면 아무곳에서나 정의해도 된다. (C에서는 사용하기 '전'에 정의해야 함)

//함수 정의 기본형태
func 함수명(매개변수1 type, 매개변수2 type) 리턴타입 {
	return 리턴값
}

• 여러 매개변수의 타입이 동일할 땐 뒤에 한번만 적어도 된다

ex) 덧셈 함수

func Add(a int, b int) int {  // Add(a, b int) int 
	return a + b
}

func main() {
	c := Add(3,6)  // c := 9
    fmt.Println(c)
}

멀티 반환 함수

: 정의 시에 리턴타입 여러개를 괄호로 묶는다.

func Divide(a, b int) (int, bool) {
	if b==0 {
    	return 0, false
    }
    return a / b, false
}

func main() {
	c, success := Divide(9,3)
    fmt.Println(c, success)
    d, success := Divide(9,0)
    fmt.Println(d, success)
}
// 3 true
// 0 false

• 같은 변수에 대해 선언대입문을 여러번 사용할 수 없는 것이 원칙이다.

a := 9
a := 3 // X 컴파일에러
a = 3 // O

• 그러나 멀티 반환 함수의 리턴값을 여러 개의 변수에 입력할 때엔, 아직 선언된 적 없는 변수가 하나라도 포함되어있을 경우 선언대입문을 사용할 수 있다.

c, success := Divide(9,3)
d, success := Divide(9,0) //O 오류없음. 
//success는 앞서 이미 선언되었지만, d는 처음 선언되기 때문에 := 사용 가능 

출력값에 이름 지정

func Divide(a, b int) (result int, success bool) {
	if b==0 {
    	result = 0
        success = false
        return 
    }
    result = a / b
    success = true
    return
}

• 함수를 정의할 때 리턴타입 앞에 리턴명도 함께 지정한다
• 함수 내부에서 선언한 리턴명에 값을 부여한다
• return 뒤에 별도로 리턴명을 작성하지 않아도 된다.

---

상수

• 상수 : 변하지 않는 수
• 타입을 지정하지 않아도 된다
• 좌변으로 사용할 수 없다 (L-value:공간, r-value:값)
• 메모리 공간이 할당되지 않는다

  const 상수명 type = 값
  ex) const ConstValue int = 10 //10인건 불변

iota로 열거값 사용

const (
	Red int = iota  // 0
    Blue int = iota  // 1
    Green int = iota  // 2
)

const (
	C1 uint = iota+1  // 1
    C2  			  // 2
    C3				  // 3
)  //비트플래그

• iota : 0부터 시작해서 반복될 때마다 1씩 값이 증가함

비트 플래그

: 각 자리에 0또는 1이 있음을 통해 특정한 의미를 가지는 것, iota로 만든다, 변수 사용을 줄여주어 메모리 절약에 도움이 된다

cost (
	MasterRoom uint8 = 1 << iota
    LivingRoom
    BathRoom
    SmallRoom
)

func SetLight(rooms, room uint8) uint8 {
	return rooms | room  // 특정 bit ON
}
func ResetLight(rooms, room uint8) uint8 {
	return rooms &^ room  // 특정 bit OFF
}
func IsLightOn(rooms, room uint8) bool {
	return rooms & room == room  // 특정 bit가 1인지 확인
}
func TurnLights(rooms uint8) {
	if IsLightOn(rooms, MastserRoom) {
    	fmt.Println("안방에 불을 켠다")
    }
    if IsLightOn(rooms, LivingRoom) {
    	fmt.Println("거실에 불을 켠다")
    }
    if IsLightOn(rooms, BathRoom) {
    	fmt.Println("화장실에 불을 켠다")
    }
    if IsLightOn(rooms, SmallRoom) {
    	fmt.Println("작은방에 불을 켠다")
    }
}

func main() {
	var rooms uint8 = 0
    rooms = SetLight(rooms, MasterRoom)  // 0000 0001
    rooms = SetLight(rooms, BathRoom)    // 0000 0101
    rooms = setLight(rooms, SmallRoom)   // 0000 0111
    rooms = ResetLight(rooms, SmallRoom) // 0000 0101
    TurnLights(rooms)
}

// 안방에 불을 켠다
// 화장실에 불을 켠다