Rust: 데이터 타입

개요

• 스칼라
  • 하나의 값으로 표현되는 타입
    • 정수형, 부동소수점 숫자, boolean, 문자
• 컴파운드
  • 같은 타입 혹은 다른 타입의 다양한 값들을 하나의 타입으로 표현
    • 배열, 튜풀
• 컬렉션
• 슬라이스
  • 컬렉션 전체가 아닌 컬렉션의 연속된 일련의 요소들을 참조
  • 참조형이므로 소유권을 갖지 않음
  • 스트링 리터럴은 스트링 슬라이스(str)
• 타입 별칭(type alias)
  • 존재하는 타입에게 다른 이름을 부여
  • type 키워드를 사용
• !
  • 빈 타입(empty type) 혹은 부정 타입(never type)
  • 발산 함수(diverging function)(반환하지 않는 함수)임을 명시
  • break 없는 loop 등
• 동적인 크기의 타입(DST - Dynamically Sized Type) 혹은 크기 없는 타입(unsized type)
  • 런타임에서만 크기를 알 수 있는 값을 이용하는 코드를 작성할 수 있게 해줌
  • &T 혹은 Box 혹은 Rc 이용
• Sized 트레잇
  • 크기가 컴파일 타임에 알려진 모든 것들에 대해 자동으로 구현
  • 암묵적으로 모든 제네릭 함수들에게 Sized를 바운드로 추가
  • fn test<T>(t: T) { -> fn test<T: Sized>(t: T) {
  • ?Sized 트레잇 바운드
    • Sized 트레잇 바운드의 반대 개념
    • fn test<T: ?Sized>(t: &T) {
    • T가 Sized 일수도 있고 아닐 수도 있다는 의미
    • Sized가 아닐수도 있으므로 포인터 필요

예제

• 코드

        fn main() {
            {
                let i: i8 = 0;
                let u: u8 = 0;

                let i: i16 = 0;
                let u: u16 = 0;

                let i: i32 = 0;
                let u: u32 = 0;

                let i: i64 = 0;
                let u: u64 = 0;

                let i: isize = 0;
                let u: usize = 0;

                let f: f32 = 1.0;
                let f: f64 = 1.0;

                let b: bool = true;
                let b: bool = false;

                let c: char = 'a';
            }

            {
                let a = [1, 2, 3, 4, 5];
                println!("1 : {}, {}", a[0], a[1]);

                let tuple: (i32, f64, char) = (1, 1.0, 'a');
                println!("2 : {}, {}, {}", tuple.0, tuple.1, tuple.2);
                let (i, f, c) = tuple;
                println!("3 : {}, {}, {}", i, f, c);
            }

            {
                let s1 = String::from("aaa");
                println!("4 : {}", s1);

                let mut s2 = String::from("aaa");
                s2.push_str(", bbb");
                println!("5 : {}", s2);
            }

            {
                let s = String::from("abcdefg");

                let slice = &s[..];
                println!("7 : {}", slice);
                println!("8 : {}", &s[0..]);
                println!("9 : {}", &s[..s.len()]);
                println!("10 : {}", &s[0..s.len()]);
                println!("11 : {}", &s[0..2]);
                println!("12 : {}", &s[..2]);
                println!("13 : {}", &s[1..3]);

                let a = [1, 2, 3, 4, 5];
                let slice = &a[1..3];
                println!("14 : {}", slice[0]);
            }

            {
                let s: &str = "abcdefg";
                println!("14 : {}", s);
            }
        }

• 실행 결과

        1 : 1, 2
        2 : 1, 1, a
        3 : 1, 1, a
        4 : aaa
        5 : aaa, bbb
        7 : abcdefg
        8 : abcdefg
        9 : abcdefg
        10 : abcdefg
        11 : ab
        12 : ab
        13 : bc
        14 : 2
        15 : abcdefg

예제 - 타입 별칭(type alias)

• 코드

        type Type1 = i32;

        fn main() {
            let i1: Type1 = 1;
            let i2: i32 = 2;

            println!("{}, {}, {}", i1, i2, i1 + i2);
        }

• 실행 결과

        1, 2, 3

예제 - !

• 코드

        fn func() -> ! {
            loop {
                println!(".");
            }
        }

        fn main() {
            func();
        }

• 실행 결과

.
.
.
...