[Rust] 자료형

---

---

개요

Rust에서의 모든 값은 특정 자료형을 가진다. 이는 Rust에게 어떤 종류의 데이터가 지정되었는지를 알려주며, 그 데이터를 어떻게 다루어야 할지 결정할 수 있게 해준다. 이 글에서는 여러 종류의 스칼라와 복합 타입에 대해 알아볼 것이다.

Rust는 정적 타입 언어이다. 이는 컴파일 시간에 모든 변수의 타입을 컴파일러가 알고 있어야 한다는 의미이다. 컴파일러는 변수에 할당된 값과 그 값의 사용 방법을 통해 타입을 추론할 수 있다. 그러나 여러 가지 타입이 올 수 있는 상황에서는(String을 숫자로 바꾸는(parse) 등의 경우), 타입을 명확히 지정해주어야 한다:

let guess: u32 = "42".parse().expect("숫자가 아닙니다!");

만약 우리가 위 코드에서 : u32라는 타입 어노테이션을 추가하지 않는다면 Rust는 아래와 같은 에러 메시지를 출력할 것이다. 이 메시지는 컴파일러가 우리가 사용할 타입에 대한 보다 구체적인 정보를 필요로 한다는 것을 나타낸다.

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0282]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^
  |
help: consider giving `guess` an explicit type
  |
2 |     let guess: _ = "42".parse().expect("Not a number!");
  |              +++

For more information about this error, try `rustc --explain E0282`.
error: could not compile `no_type_annotations` due to previous error

---

스칼라 타입

스칼라 타입은 단일 값을 나타낸다. Rust에는 네 가지 기본 스칼라 타입이 있다: 정수, 부동 소수점 숫자, 불리언, 그리고 문자이다.

이제 이 타입들이 어떻게 작동하는지 살펴보도록 하자.

---

정수 타입

정수는 소수점이 없는 숫자를 의미한다. 우리는 이전 장에서 u32와 같은 정수 타입을 사용했었다. 이 타입 선언은 바인딩된 값이 32비트의 공간을 차지하는 부호 없는 정수여야 함을 지시한다(부호가 있는 정수 타입은 u 대신 i로 시작한다). 아래 표에 Rust에서 사용할 수 있는 정수 타입이 나열되어 있다. 우리는 아래 중 하나를 사용하여 정수 타입을 선언할 수 있다.

Rust의 정수 타입

길이	부호 있음	부호 없음
8비트	i8	u8
16비트	i16	u16
32비트	i32	u32
64비트	i64	u64
128비트	i128	u128
아키텍처	isize	usize

각 타입은 부호가 있거나 없을 수 있으며, 명시적인 크기를 가지고 있다. 부호 있음과 부호 없음은 숫자가 음수인지 여부를 나타내며, 숫자에 부호가 필요한지(부호 있음), 아니면 항상 양수이므로 부호 없이 표현할 수 있는지(부호 없음)를 의미한다. 이는 숫자를 종이에 쓰는 것과 비슷하다. 부호가 중요한 경우, 숫자는 플러스 또는 마이너스 기호와 함께 작성하지만, 숫자가 양수라고 가정할 수 있는 경우에는 부호 없이 작성한다. 부호 있는 숫자는 2의 보수법을 사용하여 메모리에 저장된다.

부호 있는 타입은 각각 $-(2^{n-1})$에서 $2^{n-1} - 1$(포함) 사이의 숫자를 저장할 수 있다. 여기서 $n$은 타입이 사용하는 비트 수이다. 그러므로, i8은 $-128$부터 $127$까지의 숫자, 즉 $-(2^7)$부터 $2^7 - 1$까지를 저장할 수 있다. 반면 u8은 $0$부터 $255$, 즉 $0$부터 $2^8 - 1$ 사이의 숫자를 저장할 수 있다.

또한 isize와 usize 타입은 프로그램이 실행되는 컴퓨터의 아키텍처에 의존하는데, 이는 표에 “아키텍처”로 명시되어 있다. 64비트 아키텍처에서는 64비트, 32비트 아키텍처에서는 32비트를 사용한다.

정수 리터럴은 아래 표에 제시된 다양한 형식으로 작성할 수 있다. 다양한 타입으로 해석될 수 있는 숫자 리터럴에는 타입을 지정하는 접미사를 붙일 수도 있다. 예를 들어 57u8과 같은 형태로 사용할 수 있다. 또한 숫자 리터럴에서는 가독성을 위해 _를 사용할 수 있다. 즉, 1_000은 1000과 같은 값이다.

Rust에서의 정수 리터럴

숫자 리터럴	예시
10진법	98_222
16진법	0xff
8진법	0o77
2진법	0b1111_0000
바이트(u8 전용)	b'A'

정수 타입을 결정하는 것이 어려운 경우, Rust가 제공하는 기본값을 따르는 것을 추천하다. Rust는 특별한 지정이 없는 경우 i32를 정수의 기본 타입으로 한다. 이는 대부분의 상황에서 적절한 성능과 메모리 사용량을 제공하기 때문이다.

그러나 isize나 usize 타입은 특별한 경우에 사용되곤 한다. 이 타입들은 주로 컬렉션의 인덱싱에 사용된다. 컬렉션의 크기는 프로그램이 실행되는 시스템의 아키텍처에 의존적이기 때문에, 이 타입들은 해당 시스템에서 가장 효율적인 메모리 사용을 가능하게 한다. 따라서, 배열과 같은 컬렉션의 인덱스로 사용될 때, isize나 usize는 해당 플랫폼에 맞는 인덱스 크기를 자동으로 조정한다.

정수 오버플로우

우리가 u8 타입의 변수를 가지고 있다고 해보자. 이 변수는 $0$에서 $255$ 사이의 값을 담을 수 있다. 이 변수에 $256$ 같이 범위를 벗어난 값을 할당하려고 하면 정수 오버플로우가 발생하며, 두 가지 반응을 유발할 수 있다. 디버그 모드에서 컴파일할 때, Rust는 정수 오버플로우를 확인하는 검사를 포함하여 프로그램이 런타임 시간에 패닉 상태에 빠지도록 한다. Rust는 프로그램이 에러로 인해 종료될 때 패닉!(panic!)이라는 용어를 사용한다.

--release 플래그를 통해 릴리즈 모드로 컴파일할 때, Rust는 패닉을 일으킬 수 있는 정수 오버플로우 검사를 포함하지 않는다. 대신 오버플로우가 발생하면, Rust는 2의 보수 래핑을 실행한다. 간단히 말해서, 타입이 저장할 수 있는 최대값을 초과하는 값은 “순환”하여 타입이 저장할 수 있는 최소값이 된다. u8의 경우, $256$은 $0$이 되고, $257$은 $1$이 되는 방식이다. 이 경우 프로그램은 패닉 상태에 빠지지 않지만, 변수는 예상치 못한 값을 가지게 될 것이다. 즉, 정수 오버플로우의 래핑 동작에 의존하는 것은 에러로 간주된다.

오버플로우의 가능성을 명확히 처리하고자 할 때는, 원시 숫자 타입들에 대해 표준 라이브러리에서 제공하는 몇 가지 메서드 집합을 사용할 수 있다:

• 모든 모드에서의 래핑을 처리하는 wrapping_* 메서드 (예시: wrapping_add)
• 오버플로우가 있을 경우 None 값을 반환하는 checked_* 메서드
• 오버플로우 여부를 나타내는 불리언과 함께 값을 반환하는 overflowing_* 메서드
• 값이 최소 또는 최대 값에 도달했을 때 값을 고정하는 saturating_* 메서드

---

부동 소수점 타입

Rust는 소수점을 포함한 숫자, 즉 부동 소수점 숫자를 처리하기 위해 두 가지 기본 타입을 제공한다. Rust의 부동 소수점 타입에는 f32와 f64가 있으며, 이는 각각 32비트와 64비트의 크기를 가진다. Rust에는 f64가 기본 타입으로 지정되어 있는데, 이는 현대의 CPU가 f32와 비슷한 속도로 더 정밀한 계산을 할 수 있기 때문이다. 모든 부동 소수점 타입은 부호를 가진다.

다음은 부동 소수점 숫자를 사용하는 예시이다.

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

부동 소수점 숫자는 IEEE-754 표준을 따른다. f32 타입은 단정밀도(float)를 의미하며, f64 타입은 배정밀도(double)를 나타낸다.

숫자 연산

Rust는 다양한 숫자 타입에 대해 기본적인 숫자 연산을 지원한다. 연산에는 덧셈, 뺄셈, 곱셈, 나눗셈, 그리고 나머지 연산이 포함된다. 정수 나눗셈 연산은, 결과가 0에 가까운 쪽으로 내림된 정수 값이 된다. 다음 예시는 let 구문을 이용하여 각 숫자 연산을 어떻게 사용하는지 보여준다.

fn main() {
    // 덧셈
    let sum = 5 + 10;

    // 뺄셈
    let difference = 95.5 - 4.3;

    // 곱셈
    let product = 4 * 30;

    // 나눗셈
    let quotient = 56.7 / 32.2;
    let truncated = -5 / 3; // 결과는 -1

    // 나머지
    let remainder = 43 % 5;
}

위 코드에서, 각각의 표현식은 연산자를 사용하여 단일 값으로 평가되고, 연산의 결과 값을 변수에 바인딩한다.

---

불리언 타입

Rust에서 불리언 타입은 true와 false 두 값만을 가진다. 불리언의 크기는 한 바이트이다. Rust에서는 bool이라는 키워드로 불리언 타입을 표현한다. 예를 들면:

fn main() {
    let t = true;

    let f: bool = false; // 명시적 타입 어노테이션과 함께
}

불리언 값은 주로 조건문에서 사용된다. 특히 if 조건문 등에서 자주 볼 수 있다.

---

문자 타입

Rust의 char 타입은 다양한 문자를 표현할 수 있다. 아래에 char 타입의 사용 예가 있다.

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // 명시적 타입 어노테이션과 함께
    let heart_eyed_cat = '😻';
}

Rust에서의 char는 4바이트 크기이고, 유니코드 스칼라 값을 표현한다. 이는 ASCII 문자만을 표현하는 것이 아니라, 악센트 문자, 한국어, 중국어, 일본어 문자, 이모티콘 등도 포함할 수 있다. 예를 들어, 😻나 ℤ도 모두 유효한 char 값이다. 하지만, 유니코드의 “문자” 개념은 사람이 생각하는 일반적인 “문자” 개념과 다를 수 있다. Rust의 char가 항상 우리의 직관적 이해와 일치한다고 보장할 수는 없다.

---

복합 타입

복합 타입은 다수의 값들을 하나의 타입 안에 묶는 것을 가능하게 한다. Rust에서는 튜플과 배열이라는 두 종류의 복합 타입을 제공한다.

---

튜플 타입

튜플은 서로 다른 타입을 가진 여러 값들로 구성된 복합 타입이다. 튜플은 고정된 길이를 가지며, 한 번 선언되면 크기를 늘리거나 줄일 수 없다.

튜플은 괄호 안에 콤마로 구분된 값을 나열하여 만든다. 튜플의 각 요소는 고유한 타입을 가지며, 각 요소끼리 꼭 타입이 같을 필요는 없다. 아래 코드에서는 설명을 위해 타입 어노테이션을 추가하였다:

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

변수 tup은 전체 튜플에 바인딩된다. 튜플이 하나의 복합 요소로 간주되기 때문이다. 튜플 내의 개별 값에 접근하기 위해서는, 다음 코드와 같이 let을 통해 튜플을 구조 분해할 수 있다:

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}

이 코드는 먼저 튜플을 생성하고 tup이라는 변수에 바인딩한다. 이후 let을 사용한 패턴으로 tup을 세 개의 변수 x, y, z로 분해한다. 이 과정을 구조 분해라 부르며, 단일 튜플을 세 부분으로 나눈다. 마지막으로, 프로그램은 y의 값을 출력하며, 이 값은 6.4이다.

튜플의 요소에 직접 접근하려면 점(.) 다음에 인덱스 번호를 사용한다. 예를 들어:

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

위 코드는 x라는 튜플을 생성하고 튜플의 각 요소에 해당하는 인덱스를 사용하여 접근한다. 여기서 튜플의 첫 번째 요소는 인덱스 0을 가진다.

그리고 특별한 경우로, 값이 없는 튜플도 있는데, 이를 유닛(unit)이라고 한다. 유닛 값과 유닛 타입은 ()로 표현되며, 이는 값을 가지지 않는다는 것을 의미한다. 어떤 표현식이 값을 반환하지 않을 때는 유닛 값이 암시적으로 사용된다.

---

배열 타입

여러 값을 그룹화하는 또 다른 방법은 배열을 사용하는 것이다. 배열은 모든 요소가 동일한 타입을 가져야 한다는 점에서 튜플과 차이가 있으며, Rust의 배열은 고정된 크기를 가지고 있다는 특징이 있다.

배열은 대괄호 안에 값들을 쉼표로 구분지어 작성할 수 있다:

fn main() {
    let a = [1, 2, 3, 4, 5];
}

배열은 스택에 데이터를 할당하고자 할 때나 고정된 수의 요소를 가지고 있어야 할 때 유용하다. 하지만, 배열은 크기가 가변적인 벡터 타입처럼 유연하지 않다. 배열과 벡터 중 무엇을 선택해야 할 지 확신이 들지 않는다면, 벡터를 사용하는 것이 좋다.

반면 요소의 개수가 변하지 않아야 하는 상황에서는 배열이 더 적합하다. 예를 들어, 프로그램에서 요일의 이름을 다룬다면, 항상 7개의 요소만을 유지하기 때문에 벡터보다는 배열을 사용하는 것이 좋다.

let days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];

배열의 타입은 요소의 타입과 배열의 길이를 대괄호 안에 세미콜론과 함께 명시함으로써 표현할 수 있다:

let a: [i32; 5] = [1, 2, 3, 4, 5];

여기서 i32는 각 요소의 타입을 나타내고, 세미콜론 다음의 5는 배열이 5개의 요소를 포함한다는 것을 의미한다.

또한, 배열의 모든 요소가 동일한 값을 가지길 원한다면 초기값 하나와 배열의 길이를 세미콜론으로 구분하여 대괄호 안에 작성하면 된다:

let a = [3; 5];

이 경우 a라는 이름의 배열은 초기에 3이라는 값으로 설정된 5개의 요소를 포함하게 된다. 이 방식은 let a = [3, 3, 3, 3, 3];을 작성하는 것과 동일한 결과를 나타내지만, 더 간결한 표현 방법이다.

---

배열 요소에 접근하기

배열은 미리 정해진 크기의 메모리 블록을 스택에 할당한다. 우리는 인덱싱을 사용하여 배열 내의 특정 요소에 접근할 수 있다. 아래 코드를 보자:

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

위 코드에서 first는 배열 a의 첫 번째 요소인 1을, second는 두 번째 요소인 2를 참조한다.

---

잘못된 배열 요소 접근

배열 범위를 벗어난 인덱스로 배열에 접근하려고 하면 문제가 발생한다. “유저에게 배열의 인덱스를 입력받아 해당 요소에 접근하는” 아래 코드를 살펴보자:

아래 코드는 패닉을 유발할 수 있다.

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("배열의 인덱스를 입력해주세요.");

    let mut index = String::new();

    io::stdin()
        .read_line(&mut index)
        .expect("줄을 읽는 데 실패했습니다.");

    let index: usize = index
        .trim()
        .parse()
        .expect("입력한 인덱스가 숫자가 아닙니다.");

    let element = a[index];

    println!("인덱스 {index}에 있는 요소의 값은 다음과 같습니다: {element}");
}

위 코드는 성공적으로 컴파일된다. cargo run으로 코드를 실행하고, 0, 1, 2, 3, 또는 4를 입력하면 프로그램은 배열에서 해당 인덱스의 값을 출력한다. 그러나 만약 배열의 범위를 넘어서는 숫자인 10과 같은 수를 입력한다면 다음과 같은 메시지를 보게 될 것이다:

thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19
note: run with 'RUST_BACKTRACE=1' environment variable to display a backtrace

이 메시지는 인덱싱 작업 중 잘못된 값 사용으로 발생한 런타임 에러를 나타낸다. 프로그램은 에러 메시지를 출력하고 종료된다. 여기서 마지막 println! 명령은 실행되지 않는다. 요소에 접근하기 위해 인덱싱을 시도할 때 Rust는 지정한 인덱스가 배열의 길이보다 작은지 확인한다. 만약 인덱스가 길이와 같거나 큰 경우, Rust는 패닉한다. 이 검사는 런타임 시간에 수행되어야 한다. 왜냐하면, 컴파일러는 유저가 어떤 값을 입력할지 예측할 수 없기 때문이다.

이 상황은 Rust의 메모리 안전성 원칙을 보여주는 사례이다. 다수의 저수준 언어에서는 이러한 종류의 검사가 수행되지 않아, 유저가 부적절한 인덱스를 제공할 경우 잘못된 메모리 영역에 접근하는 문제가 발생할 수 있다. Rust는 이러한 에러를 방지하기 위해 잘못된 메모리 접근을 허용하는 상황 대신에, 프로그램을 즉각적으로 종료함으로써 유저를 보호한다.

---

출처: rust-lang book