[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();
     }
    

• 실행 결과

  • .
    .
    .
    ...