데이터 타입

동작하는 코드

아래 코드를 Rust Playground에서 실행해보세요!

fn main() {
    let age: i32 = 20;          // 정수
    let height: f64 = 175.5;    // 실수
    let is_student: bool = true; // 불리언
    let grade: char = 'A';      // 문자

    println!("나이: {age}");
    println!("키: {height}cm");
    println!("학생인가요? {is_student}");
    println!("등급: {grade}");
}

Rust에는 4가지 기본 스칼라 타입(scalar type) 이 있어요.

| 종류 | 예시 | 설명 | | ------ | ------ | --------------------------- | | 정수 | i32 | 소수점 없는 숫자 | | 실수 | f64 | 소수점 있는 숫자 | | 불리언 | bool | true 또는 false | | 문자 | char | 작은따옴표로 감싼 글자 하나 |

사실 타입을 안 써도 Rust가 알아서 추론해줘요.

fn main() {
    let age = 20;       // i32로 추론
    let height = 175.5; // f64로 추론
    let is_happy = true; // bool로 추론
    let emoji = '🦀';   // char로 추론

    println!("{age}, {height}, {is_happy}, {emoji}");
}

타입을 직접 쓰지 않아도 Rust 컴파일러가 값을 보고 타입을 알아내요. 이걸 타입 추론(type inference) 이라고 해요.

직접 수정하기

아래 코드에서 타입 표기(: i32, : f64 등)를 지워보세요. 결과가 달라지나요?

fn main() {
    let x: i32 = 42;
    let y: f64 = 3.14;
    let z: bool = false;

    println!("{x}, {y}, {z}");
}

타입을 빼도 같은 결과가 나와요. Rust가 알아서 추론해주거든요. 하지만 타입을 써두면 코드를 읽는 사람이 더 쉽게 이해할 수 있어요.

"왜?" — 타입이 왜 필요할까요?

컴퓨터는 숫자 42와 소수 3.14를 저장하는 방식이 달라요. 정수는 정수 방식으로, 실수는 실수 방식으로 메모리에 저장되거든요. 컴파일러가 타입을 알아야 값을 메모리에 올바르게 저장하고, 연산도 정확하게 할 수 있어요.

Rust는 서로 다른 타입끼리 연산하는 것을 허용하지 않아요. 이것 덕분에 의도하지 않은 실수를 미리 잡을 수 있어요.

fn main() {
    let a: i32 = 10;
    let b: f64 = 3.0;

    // 이렇게 하면 에러!
    // let result = a + b;

    // 타입을 맞춰줘야 해요
    let result = a as f64 + b;
    println!("결과: {result}");
}

as 키워드로 타입을 변환할 수 있어요. 지금은 "타입이 다르면 맞춰줘야 한다"는 것만 기억하세요.

심화 학습

fn main() {
    let x = 5;
    let y = 2.0;
    let sum = x + y;

    println!("{sum}");
}

error[E0277]: cannot add `{float}` to `{integer}`
 --> src/main.rs:4:19
  |
4 |     let sum = x + y;
  |                   ^ no implementation for `{integer} + {float}`

fn main() {
    let x: i32 = 10;
    let y: f64 = 3.0;
    let z = x + y;
    println!("{z}");
}