[GO] Tucker의 GO 언어 프로그래밍 - 4장 연산자

ㅁ 들어가며

ㅇ Tucker의 GO 언어 프로그래밍 책을 보고 정리한 글입니다.

ㅇ 4장 연산자 - 연산자종류

 

 

ㅁ 산술 연산자

산술 연산자는 수학적 계산을 수행

a, b := 10, 20
fmt.Println(a + b)  // 30 (덧셈)
fmt.Println(a - b)  // -10 (뺄셈)
fmt.Println(a * b)  // 200 (곱셈)
fmt.Println(b / a)  // 2 (나눗셈)
fmt.Println(b % a)  // 0 (나머지)
a++  // 증가
b--  // 감소

ㅇ 모든 연산자의 각 항의 타입은 항상 같아야한다.

ㅇ 정수 타입과 실수 타입을 서로 더하거나 뺄 수 없다.

 

ㅁ 비트 연산자

비트 연산자는 정수의 비트를 직접 조작하는 데 사용

a := 6 // 0110
b := 5 // 0101

# &: AND 연산 (두 비트가 모두 1일 때 1)
fmt.Printf("AND(&): %08b\n", a & b)   // 00000100

# |: OR 연산 (하나 이상의 비트가 1일 때 1)
fmt.Printf("OR(|): %08b\n", a | b)    // 00000111

# ^: XOR 연산 (두 비트가 다를 때 1)
fmt.Printf("XOR(^): %08b\n", a ^ b)   // 00000011

# &^: 비트 클리어 (첫 번째 값에서 두 번째 값의 비트를 제거)
fmt.Printf("AND NOT(&^): %08b\n", a &^ b) // 00000010

# 출력
AND(&): 00000100
OR(|): 00000111
XOR(^): 00000011
AND NOT(&^): 00000010

 

ㅁ 시프트 연산자

시프트 연산자는 비트를 왼쪽 또는 오른쪽으로 이동

a := 6 // 0110

fmt.Printf("Original: %08b\n", a)     // 00000110

# <<: 왼쪽 시프트 (지정한 수만큼 비트를 왼쪽으로 이동, 빈 자리는 0으로 채움)
fmt.Printf("Left shift(<<2): %08b\n", a << 2) // 00011000

# >>: 오른쪽 시프트 (지정한 수만큼 비트를 오른쪽으로 이동, 빈 자리는 부호에 따라 채움)
fmt.Printf("Right shift(>>1): %08b\n", a >> 1) // 00000011

# 출력
Original:      00000110
Left shift(<<2):   00011000
Right shift(>>1):  00000011

ㅇ 오른쪽 피연산자는 반드시 양의 정수이다.

ㅇ 시프트 결과가 타입 범위를 벗어하면 초과된 비트는 버려진다.

 

var x int8 = -128 // 음수 값
var y uint8 = 128 // 양수 값

fmt.Printf("x:%08b x>>2:%08b x>>2:%d\n", x, x>>2, x>>2) // 부호 유지됨 (-32)
fmt.Printf("y:%08b y>>2:%08b y>>2:%d\n", y, y>>2, y>>2) // 빈 자리는 0으로 채움 (32)

# 출력
x:10000000 x>>2:11100000 x>>2:-32
y:10000000 y>>2:00100000 y>>2:32

ㅁ 비교 연산자

비교 연산자는 두 값을 비교하고 불리언 결과를 반환

x, y := 5, 10
fmt.Println(x == y)  // false (같음)
fmt.Println(x != y)  // true (다름)
fmt.Println(x  y)   // false (초과)
fmt.Println(x = y)  // false (이상)

 

ㅁ 논리 연산자

논리 연산자는 불리언 값을 조합

p, q := true, false
fmt.Println(p && q)  // false (AND)
fmt.Println(p || q)  // true (OR)
fmt.Println(!p)      // false (NOT)

 

ㅁ 대입 연산자

대입 연산자는 변수에 값을 할당함.

var a int = 10
a += 5  // a = a + 5
fmt.Println(a)  // 15

b := 20
b *= 2  // b = b * 2
fmt.Println(b)  // 40

c := 15
c %= 4  // c = c % 4
fmt.Println(c)  // 3

 

ㅁ 연산자 우선순위

연산자 우선순위는 복잡한 표현식에서 연산 순서를 결정함.

result := 5 + 3 * 2
fmt.Println(result)  // 11 (곱셈이 먼저 수행됨)

result = (5 + 3) * 2
fmt.Println(result)  // 16 (괄호 안의 연산이 먼저 수행됨)

logicalResult := true || false && !true
fmt.Println(logicalResult)  // true (NOT, AND, OR 순으로 평가됨)

ㅇ 연산자 우선순위는 일반적으로 다음과 같다.

1. 괄호 ()
2. 단항 연산자 (++, --, !)
3. 산술 연산자 (*, /, %, +, -)
4. 비교 연산자 (, >=, ==, !=)
5. 논리 연산자 (&&, ||)
6. 대입 연산자 (=, +=, -=, 등)

 

ㅁ 함께 보면 좋은 사이트

ㅇ Go - Arithmetic Operators

ㅇ 공봉식 - Tucker의 GO 언어 프로그래밍

ㅇ 구글 도서 - Tucker의 GO 언어 프로그래밍