[Golang] Constant 정수 선언

이 글은 Constant in Go (Golang) - Welcome To Golang By Example을 번역 및 재가공하여 작성하였습니다.

Constant in Go (Golang) - Welcome To Golang By Example

 

목차

 

1. 정수 선언

1-1. 정수 선언하기

package main
func main() {
    const a int = 8	// 1. 타입 명시
    const b = "str" // 2. 타입 추측
    const (         // 3. 동시 선언
        c = 1.1
        d = true
    )
    
    fmt.Println(a, b, c, d)
}

8 str 1.1 true

 

1-2. 제약조건

package main

import "fmt"

const d = "d"

func main() {
	const a               // 1. 반드시 초기값을 넣어야 한다.
	const b = 1 
	b = 2                 // 2. 값을 변경할 수 없다.
    
    const c = returnOne() // 3. 컴파일 당시에 값을 알아야 한다.
    
    const d = "dd"        // 4. 외부와 동일한 상수명이 함수 내부에 있는 경우 내부의 값을 사용한다.
    
    fmt.Println(a, b, c, d)
}

func returnOne() int {
    return 1
}

./prog.go:8:8: missing value in const declaration
./prog.go:10:4: cannot assign to b (declared const)
./prog.go:12:11: const initializer returnOne() is not a constant
./prog.go:16:17: undefined: a

 

1-3. 타입을 선언한 상수는 암시적 변환을 할 수 없다.

Go의 상수는 다른 언어와는 다르게 반드시 명시적 변환을 해야합니다.

package main

func main() {
    const a int32 = 8

    var i1 int32
    var i2 int64

    i1 = a
    i2 = a
}

./prog.go:10:5: cannot use a (type int32) as type int64 in assignment

 

1-4. 타입을 선언하지 않은 상수

예시

// 이름이 없는 상수
123
"문자열"
1.23
true
'a'
1+2i

// 타입이 지정되지 않은 상수
const (
    a = 1
    b = "문자열"
    c = 1.23
    d = true
    e = 'a'
    f = 1+2i
)

1-3에서 설명했 Go는 반드시 타입변환을 해야하는 Strong 타입 언어입니다.

하지만 타입을 선언하지 않은 상수에는 유연성이 제공됩니다.

math 패키지에 포함된 상수 Pi입니다. 이 상수는 타입이 지정되지 않았습니다.

const Pi = 3.14159265358979323846264338327950288419716939937510582097494459

package main
import (
    "fmt"
    "math"
)
func main() {
    const f1 float32 = math.Pi
    const f2 float64 = math.Pi

    fmt.Printf("Type: %T Value: %v\n", math.Pi, math.Pi)
    fmt.Printf("Type: %T Value: %v\n", f1, f1)
    fmt.Printf("Type: %T Value: %v\n", f2, f2)
}

Type: float64 Value: 3.141592653589793
Type: float32 Value: 3.1415927
Type: float64 Value: 3.141592653589793

f1이 자동으로 형변환이 된 것을 확인할 수 있습니다.

 

아래 코드를 읽어보면 좀 더 명확해 집니다.

package main

import "fmt"

func main() {
	type myString string

	// Typed String constant
	const aa string = "abc"
	var uu = aa
	fmt.Println("Untyped named string constant")
	fmt.Printf("uu: Type: %T Value: %v\n\nn", uu, uu)

	// 아래 코드는 컴파일 에러가 발생합니다.
	// 왜냐하면 aa는 string타입이기 때문에 myString에 대입할 수 없습니다.
	// var v myString = aa

	// Untyped named string constant
	const bb = "abc"
	var ww myString = bb // bb는 타입을 지정하지 않았기 때문에 자동 변환이 일어납니다.
	var xx = bb
	fmt.Println("Untyped named string constant")
	fmt.Printf("ww: Type: %T Value: %v\n", ww, ww)
	fmt.Printf("xx: Type: %T Value: %v\n\n", xx, xx)

	// Untyped unnamed string constant
	var yy myString = "abc"
	var zz = "abc"
	fmt.Println("Untyped unnamed string constant")
	fmt.Printf("yy: Type: %T Value: %v\n", yy, yy)
	fmt.Printf("zz: Type: %T Value: %v\n", zz, zz)
}

Untyped named string constant
uu: Type: string Value: abc

nUntyped named string constant
ww: Type: main.myString Value: abc
xx: Type: string Value: abc

Untyped unnamed string constant
yy: Type: main.myString Value: abc
zz: Type: string Value: abc

 

1-5. 여러 상수를 동시에 선언하기

상수를 선언할 때 같은 값을 넣는다면 생략할 수 있다.

package main

import "fmt"

func main() {
	const (
		a = 1
		b // a와 같은 값이 들어간다.
		c = "a"
	)
	var (
		d = 2
		e = 1 // var는 생략할 수 없다.
		f = false
	)
	fmt.Println(a, b, c, d, e, f)
}

1 1 a 2 1 false

 

1-6. 상수가 될 수 있는 타입

상수가 될 수 있는 타입은 4가지이다. Map, struct, array는 컴파일 에러가 발생한다.

1. Numeric(int, int64, float, float64, complex128, 등)
2. String
3. Character 또는 rune
4. Boolean

package main

import "fmt"

type employee struct {
    name string
    age  int
}

func main() {
	const (
		a int = 1
		b string = "asdf"
		c rune = 'a'
		d = true
	)
	const e = map[string]int{ // error발생
		"a": 1,
	}
	const f = employee{ // error발생
		name: "Jone",
		age: 21,
	}
	const g = [1]int{1} // error발생
	
	fmt.Println(a, b, c, d, e, f, g)
}

./prog.go:17:8: const initializer map[string]int{...} is not a constant
./prog.go:20:8: const initializer employee{...} is not a constant
./prog.go:24:8: const initializer [1]int{...} is not a constant