빌림과 참조

동작하는 코드

이전 모듈에서 함수에 값을 넘기면 소유권이 이동된다고 배웠어요. clone()으로 해결할 수 있었지만, 매번 복사하는 건 비효율적이에요.

더 좋은 방법이 있어요 — 빌림(borrowing) 이에요!

fn print_message(msg: &String) {
    // msg는 빌려온 값 — 읽기만 가능
    println!("{msg}");
}

fn main() {
    let message = String::from("안녕하세요!");
    print_message(&message);     // 빌려주기
    println!("아직 사용 가능: {message}"); // 주인은 그대로!
}

&가 핵심이에요. &message는 "이 값을 빌려줄게"라는 뜻이고, 매개변수 msg: &String은 "빌린 값을 받을게"라는 뜻이에요.

직접 수정하기

1. 모듈 09에서 에러가 났던 코드를 빌림으로 고쳐보세요.

fn print_fruits(fruits: Vec<&str>) {
    for f in fruits {
        println!("{f}");
    }
}

fn main() {
    let fruits = vec!["사과", "바나나"];
    print_fruits(fruits);
    println!("과일 수: {}", fruits.len()); // 에러!
}

힌트: 함수의 매개변수와 호출 부분에 &를 추가해보세요. for f in fruits도 for f in fruits로 바뀔 수 있어요.

2. clone() 없이 같은 결과를 낼 수 있나요? 직접 확인해보세요!

"왜?" — 도서관 대출로 이해하기

빌림을 도서관 대출로 생각하면 쉬워요.

• 도서관(주인)에서 책(값)을 빌려가면, 도서관은 여전히 책의 주인이에요
• 빌린 사람은 책을 읽을 수 있지만, 페이지를 찢으면 안 돼요(불변 빌림)
• 빌린 기간이 끝나면 반납해야 해요

fn calculate_length(s: &String) -> usize {
    s.len()
    // 함수가 끝나면 빌린 값이 반납돼요
}

fn main() {
    let word = String::from("Rust");
    let len = calculate_length(&word);
    println!("{word}의 길이: {len}");
}

&word로 빌려줬기 때문에 소유권은 이동하지 않아요. 함수가 끝나면 빌린 참조가 자동으로 반납돼요.

가변 빌림 — 편집 권한

읽기만 하는 게 아니라 수정도 하고 싶다면? &mut을 사용해요.

fn add_exclamation(s: &mut String) {
    s.push_str("!!!");
}

fn main() {
    let mut message = String::from("안녕");
    add_exclamation(&mut message);
    println!("{message}"); // "안녕!!!"
}

가변 빌림을 편집 권한으로 생각하면 돼요.

• 읽기 권한(&): 여러 명이 동시에 가질 수 있어요
• 편집 권한(&mut): 한 명만 가질 수 있어요

왜 편집 권한은 한 명만 가능할까요? 여러 사람이 동시에 같은 문서를 수정하면 내용이 꼬이잖아요. Rust가 이걸 컴파일할 때 막아줘요.

빌림 규칙 정리

1. 불변 참조(&)는 여러 개 동시에 존재할 수 있다
2. 가변 참조(&mut)는 하나만 존재할 수 있다
3. 불변 참조와 가변 참조는 동시에 존재할 수 없다

fn main() {
    let mut data = String::from("hello");

    let r1 = &data;     // OK — 읽기 권한 1
    let r2 = &data;     // OK — 읽기 권한 2
    println!("{r1}, {r2}");

    let r3 = &mut data; // OK — 읽기 권한이 더 이상 사용되지 않으니까
    r3.push_str(" world");
    println!("{r3}");
}

error[E0502]: cannot borrow `data` as mutable because it is
              also borrowed as immutable
 --> src/main.rs:6:14
  |
4 |     let r1 = &data;
  |              ----- immutable borrow occurs here
5 |     let r2 = &data;
6 |     let r3 = &mut data;
  |              ^^^^^^^^^ mutable borrow occurs here
7 |     println!("{r1}, {r2}");
  |               --- immutable borrow later used here

fn main() {
    let mut data = String::from("hello");

    let r1 = &data;
    println!("{r1}");      // r1의 마지막 사용

    let r2 = &mut data;    // OK! r1은 이미 사용이 끝남
    r2.push_str(" world");
    println!("{r2}");
}

fn greet(name: String) {
    println!("안녕, {name}!");
}

fn main() {
    let name = String::from("지수");
    greet(name);
    greet(name); // 에러! name이 이동됨
}

fn main() {
    let mut numbers = vec![1, 2, 3];
    let first = &numbers[0];
    numbers.push(4);
    println!("첫 번째: {first}");
}

fn first_word(s: &String) -> &str {
    // 여기를 완성하세요!
    // 힌트: s.find(' ')와 &s[..index]를 사용해보세요
}

fn main() {
    let sentence = String::from("hello world");
    let word = first_word(&sentence);
    println!("첫 단어: {word}");
}

fn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &mut s;
    println!("{r1}");
}