3장 - 기본 데이터 구조 자료형

구조체

• struct는 필드(field)들의 컬렉션

struct SeaCreature {
    // String은 struct다
    animal_type: String,
    name: String,
    arms: i32,
    legs: i32,
    weapon: String,
}

메소드 호출하기

• 메소드는 특정 데이터 자료형과 연관된 함수

• 스태틱 메소드(static methods) - 자료형 그 자체에 속하는 메소드. :: 연산자로 호출

• 인스턴스 메소드(instance methods) - 자료형의 인스턴스에 속하는 메소드. . 연산자로 호출

fn main() {
    // static method를 사용하여 String의 instance를 생성
    let s = String::from("Hello world!");

    // instance의 메소드를 사용
    println!("{}의 글자 수는 {}입니다.", s, s.len());
}

메모리

1. 데이터 메모리(data memory)
• 고정된 크기의 static한 데이터용. (Ex> “Hello World!”) 일반적으로 빠름

2. 스택 메모리(stack memory)
• 함수 내에서 변수로 선언. 함수 호출 동안에는 변하지 않으므로 컴파일러가 관리

3. 힙 메모리(heap memory)
• 애플리케이션이 실행되는 동안 생성되는 동적 메모리. 느리지만 유연함. 할당(allocation) 및 해제(deallocation)

메모리에 데이터 생성하기

• 구조체를 인스턴스화(instantiate)하면 연관된 필드가 메모리에 로드

• StructName { ... } 형식으로 필드 값을 지정함으로써 인스턴스화

• 구조체 필드 값은 . 연산자로 접근

struct SeaCreature {
    animal_type: String,
    name: String,
    arms: i32,
    legs: i32,
    weapon: String,
}

fn main() {
    // SeaCreature의 데이터는 stack에 있음
    let ferris = SeaCreature {
        // String struct도 stack에 있지만,
        // heap에 있는 데이터에 대한 참조를 갖고 있음
        animal_type: String::from("게"),
        name: String::from("Ferris"),
        arms: 2,
        legs: 4,
        weapon: String::from("집게"),
    };

    let sarah = SeaCreature {
        animal_type: String::from("문어"),
        name: String::from("Sarah"),
        arms: 8,
        legs: 0,
        weapon: String::from("없음"),
    };

    println!(
        "{}는 {}이다. {}개의 팔과, {}개의 다리와, {}를 무기로 갖고 있다.",
        ferris.name, ferris.animal_type, ferris.arms, ferris.legs, ferris.weapon
    );
    println!(
        "{}는 {}이다. {}개의 팔과, {}개의 다리를 갖고 있다. 무기는 없다..",
        sarah.name, sarah.animal_type, sarah.arms, sarah.legs
    );
}

• "Ferris” 와 같은 텍스트는 데이터 메모리(data memory)에 위치

• String::from 메소드 호출은 String 구조체를 생성하여 SeaCreature 구조체의 필드들과 스택에 위치

• String은 변경 될 수 있는 텍스트
• 힙(heap) 메모리 생성
• 메모리 위치에 대한 참조를 heap에 저장 → String struct에 저장 (뒤에 자세히 나옴)

• ferris와 sarah는 프로그램내 고정된 위치의 자료 구조. → 스택(stack)에 위치

Tuple 같은 구조체

struct Location(i32, i32);  // 필드명 없이 자료형만 정의. {} -> ()

fn main() {
    // 이것도 여전히 stack에 있는 struct임
    let loc = Location(42, 32);
    println!("{}, {}", loc.0, loc.1);
}

Unit 같은 구조체

• 아무 필드 없는 구조체 가능

• unit은 빈 tuple인 ()의 또 다른 이름

• 거의 안씀

struct Marker;

fn main() {
    let _m = Marker;
}

열거형

• enum 키워드로 열거형 정의

#![allow(dead_code)] // 이 줄은 컴파일러 경고를 방지해줌

enum Species {
    Crab,
    Octopus,
    Fish,
    Clam,
}

struct SeaCreature {
    species: Species,  // 열거형으로 정의된 자료형
    name: String,
    arms: i32,
    legs: i32,
    weapon: String,
}

fn main() {
    let ferris = SeaCreature {
        species: Species::Crab,
        name: String::from("Ferris"),
        arms: 2,
        legs: 4,
        weapon: String::from("claw"),
    };

    match ferris.species {  // 열거형 원소별 처리
        Species::Crab => println!("{}는 게이다", ferris.name),
        Species::Octopus => println!("{}는 문어이다", ferris.name),
        Species::Fish => println!("{}는 물고기이다", ferris.name),
        Species::Clam => println!("{}는 조개이다", ferris.name),
    }
}

열거형과 데이터

• enum의 원소들은 C의 union처럼 한 개 이상의 자료형을 가질 수 있음

• enum이 match를 통해 패턴 일치될 때, 각각의 데이터 값을 변수에 바인딩할 수 있음

• enum 메모리 상세:
• enum은 가장 큰 원소의 메모리 크기를 가짐. 모든 잠재적 값이 같은 메모리 공간에 들어감
• enum 원소의 자료형과 각 원소가 어떤 태그인지 나타내는 숫자 값도 있음

• Rust의 열거형은 태그가 지정된 공용체(union)라고도 함

• 타입을 결합하여 새로운 타입을 만드는 것 → Rust에 대수적 타입(algebraic types)이 있다는 것을 의미

#![allow(dead_code)] // 이 줄은 컴파일러 경고를 방지해줌

enum Species {
    Crab,
    Octopus,
    Fish,
    Clam,
}
enum PoisonType {
    Acidic,
    Painful,
    Lethal,
}
enum Size {
    Big,
    Small,
}
enum Weapon {
    Claw(i32, Size),
    Poison(PoisonType),
    None,
}

struct SeaCreature {
    species: Species,
    name: String,
    arms: i32,
    legs: i32,
    weapon: Weapon,
}

fn main() {
    // SeaCreature의 데이터는 stack에 있음
    let ferris = SeaCreature {
        // String struct도 stack에 있지만,
        // heap에 있는 데이터에 대한 참조를 갖고 있음
        species: Species::Crab,
        name: String::from("Ferris"),
        arms: 2,
        legs: 4,
        weapon: Weapon::Claw(2, Size::Small),
    };

    match ferris.species {
        Species::Crab => match ferris.weapon {
            Weapon::Claw(num_claws, size) => {
                let size_description = match size {
                    Size::Big => "큰",
                    Size::Small => "작은",
                };
                println!(
                    "ferris는 {}개의 {} 집게를 가진 게이다",
                    num_claws, size_description
                )
            }
            _ => println!("ferris는 다른 무기를 가진 게이다"),
        },
        _ => println!("ferris는 다른 동물이다"),
    }
}

The Rust Programming Language 링크

1. 소유권이 뭔가요? (메모리 관련 내용)

2. 구조체로 연관된 데이터를 구조화하기

3. 열거형과 패턴 매칭