[Rust] 구조체

개요

• 필드 초기화 축약법(field init shorthand)
  • 변수명과 구조체의 필드명이 같을 경우 변수명만으로 초기화 가능
• 구조체 갱신법(struct update syntax)
  • .. 구문을 사용하여 기존 구조체의 값으로 초기화
• 튜플 구조체(tuple structs)
  • 필드의 타입만 정의하여 튜플과 유사한 구조를 갖는 구조체
• 유사 유닛 구조체(unit-like structs)
  • 필드가 없이 정의하여 유닛 타입인 ()와 비슷하게 동작하는 구조체
• 연관 함수 (associated functions)
  • self 파라미터를 갖지 않는 함수

예제

• 코드

  •  #[derive(Debug)]
     struct Test {
         i: i32,
         s: String,
     }
            
     impl Test {
         fn print(&self, prefix: i32) {
             println!("{} : {}, {}", prefix, self.i, self.s);
         }
            
         fn get_i(&self) -> i32 {
             self.i
         }
            
         fn set_i(&mut self, i: i32) {
             self.i = i;
         }
            
         fn from(i: i32, s: String) -> Test {
             Test { i, s }
         }
     }
            
     fn main() {
         {
             let test = Test {
                 i: 1,
                 s: String::from("a"),
             };
             println!("1 : {}, {}", test.i, test.s);
         }
            
         {
             let mut test = Test::from(1, String::from("a"));
            
             test.print(2);
             test.set_i(3);
             println!("3 : {}", test.get_i());
         }
            
         // field init shorthand
         {
             let i = 1;
             let s = String::from("a");
            
             let test = Test { i, s };
             println!("4 : {:?}", test);
         }
            
         // struct update syntax
         {
             let test1 = Test {
                 i: 1,
                 s: String::from("a"),
             };
            
             let test2 = Test {
                 s: String::from("b"),
                 ..test1
             };
             println!("5 : {:?}", test1);
             println!("6 : {:#?}", test2);
         }
            
         // tuple structs
         {
             struct TS(i32, String);
            
             let ts = TS(1, String::from("a"));
             println!("7 : {}, {}", ts.0, ts.1);
         }
            
         // unit-like structs
         {
             struct ULS();
            
             let uls = ULS();
         }
     }
    

• 실행 결과

  •  1 : 1, a
     2 : 1, a
     3 : 3
     4 : Test { i: 1, s: "a" }
     5 : Test { i: 1, s: "a" }
     6 : Test {
         i: 1,
         s: "b",
     }
     7 : 1, a