[GoLang] 연산자

Go 언어의 연산자는 C언어랑 비슷하게 있습니다.

 

1. 산술 연산자

+, -, *, /, % 가 존재합니다.

const c int = 2
// 덧셈(+)
a := 1 + 2                // 두 정수 더하면서 변수 선언
b := a + c                // 두 변수 더하면서 변수 선언
str := "Hello, " + "Go!"  // 두 문자열 붙이면서 새 문자열 선언
 
// 뺄셈(-)
d := a - b                // 두 변수 빼면서 변수 선언
 
// 곱셈(*), 나눗셈(/), 나머지(%)
e := a * b                // 두 변수 곱하면서 변수 선언
f := e / a                // 두 변수 나누면서 변수 선언
g := b % 2                // 나머지 연산 하며 변수 선언
 
fmt.Println(a ,b, c, d, e, f, g, str)

결과

산술 연산 결과

++, -- 도 당연히 존재합니다.

++, --

package main
 
import "fmt"
 
func main() {
    a := 10
    a++
    fmt.Println(a)
 
    b := 4.14
    b--
    fmt.Println(b)
 
    c := 2 + 2i // 복소수 2 + 2i
    c++
    fmt.Println(c)
}
 

결과

++, -- 연산 결과

단 Go에서는 할당과 동시에 ++,-- 연산자 사용이 불가능 합니다.

아래와 같은 사용은 에러가 납니다.

package main
import "fmt"
func main() {
    a := 1
    b := a++ // 컴파일 에러
    c := ++a // 컴파일 에러
    ++a      // 컴파일 에러
}

++연산자 에러

 

 

2. 비트 연산자

비트연산자는 and, or, shift, xor 가 있습니다.

&, |, <<, >>, ^

// You can edit this code!
// Click here and start typing.
package main
 
import "fmt"
 
func main() {
    var a int = 0x1020
    var b int = 0x1111
    shift := b << 1
    shift2 := a >> 1
    and := a & b
    or := a | shift
    xor := a ^ b
    fmt.Printf("a = %d(0x%x(%b))\nb = %d(0x%x(%b))\n", a, a, a, b, b, b)
    fmt.Printf("shift = %x (%b,%d)\n", shift, shift, shift)
    fmt.Printf("shift2 = %x (%b,%d)\n", shift2, shift2, shift2)
    fmt.Printf("a & b = 0x%x,%b\n", and, and)
    fmt.Printf("a | b = 0x%x,%b\n", or, or)
    fmt.Printf("a ^ b = 0x%x,%b\n", xor, xor)
 
}

결과

비트연산 결과

 

and not 같은 녀석도 있다고 합니다.

&^

package main
 
import "fmt"
 
func main() {
    a := 255     // 11111111
    b := 100     // 01100100
    c := a &^ b  // 10011011
    fmt.Printf("     %08b\n", a) // 11111111
    fmt.Printf("&^   %08b\n", b) // 01100100
    fmt.Println("-------------")
    fmt.Printf("     %08b", c)  // 10011011
}
 

and not 연산 결과

이런 방식으로 특정 비트를 꺼버릴 수 있습니다.

 

 

3. 논리 연산자

and, or, not 이 존재합니다.

 &&, ||, !

사용 방법은 말안해도 알겠지만 일단 적어두겠습니다.

package main
 
import "fmt"
 
func main() {
    a := true
    b := false
    fmt.Println(a && b)
    fmt.Println(a || b)
    fmt.Println(!a)
    fmt.Println(!(a && b))
    fmt.Println(!(a || b))
}
 

결과

논리 연산 결과

 

 

4. 할당 연산자(대입 연산자)

=

var a int = 100
var b int = 200
const c int = b
const d string = "Go Lang"
 
a = c
 

이런식으로 선언할 때 사용하거나 이미 선언된 변수끼리 대입할때 사용합니다.

 

:= 

a := 100
b := 200
string := "HaHa"

이건 선언과 동시에 대입할때 사용합니다. 이전 글에서 소개했었습니다.

 

+=, -=, /=, *=, %=, &=, |=, <<=, >>=, ^=

과 같이 연산후 할당(대입) 사용 방법도 당연히 존재합니다.

사용법은 생략합니다.

 

5.관계 연산자

==, !=, >, <, >=, <= 이 존재합니다.

package main
 
import "fmt"
 
func main() {
    fmt.Println(1 == 1)             // true
    fmt.Println(1 < 3)             // true
    fmt.Println(1 > 0)             // true
    fmt.Println(3.5 != 5.5)         // true
    fmt.Println("Hello" == "world") // false
 
    a := [3]int{10, 20, 30}
    b := [3]int{10, 20, 30}
    fmt.Println(a == b) // true
 
    c := []int{1, 2, 3}
    // 슬라이스를 nil과 비교하여 메모리가 할당되었는지 확인
    fmt.Println(c == nil) // false
    
 
    d := map[string]int{"Go": 1}
    // 맵을 nil과 비교하여 메모리가 할당되었는지 확인
    fmt.Println(d != nil) // true
 
    e := 1
    f := 1
    var p_e *int = &e
    var p_f *int = &f
    fmt.Println(p_e != p_f) // true
}

와 같이 사용 가능합니다.

 

 

6. 기타 연산자

이외에도 Sizeof, *, &, <- 같은 연산자들이 존재합니다. 

Sizeof는 변수나 상수가 메모리에서 가지는 크기를 보여줍니다. 사용하기 위해서 unsafe를 import 해야합니다.

*, & 는 포인터 연산자입니다.

<- 채널 연산자입니다. Go루틴에서 사용되고 채널에 값을 보내거나 받아올때 사용합니다.

package main
 
import (
    "fmt"
    "unsafe"
)
 
func main() {
    a := 1
    fmt.Println(unsafe.Sizeof(a))
    b := &a
    fmt.Println(b)
    p := new(int)
    *p = 1
    fmt.Println(*p)
}
 

결과

기타 연산자들

채널 연산자에 대해서는 나중에 설명하겠습니다.

 

7. 연산자 우선순위

당연하지만 우선순위가 존재합니다.

우선순위가 큰것이 먼저 수행됩니다.

우선순위	연산자
5	* / % << >> & &^
4	+ - | ^|
3	== != < <= > >=
2	&&
1	||

필요하다면 괄호()를 이용합니다.