참조와 대여

소유권이 뭔가요?의 마지막 예제에서는 String이 calculate_length로 이동해 버리므로, 함수를 부른 뒤에도 그 String을 쓰려면 튜플로 돌려받아야 했습니다. 이 글에서는 그 대신 값의 참조(reference)를 넘기는 방법을 살펴봅니다. 참조는 다른 값이 있는 곳을 가리키되 그 값을 소유하지 않는 값으로, 참조를 통해 그 값에 접근할 수 있습니다. 포인터와 비슷하지만, 참조는 쓰이는 동안 언제나 해당 타입의 유효한 값을 가리킨다는 것을 컴파일러가 보장합니다.

참조로 값 넘기기

다음은 소유권을 넘기지 않고 참조를 받도록 calculate_length를 고친 코드입니다. 앞 글에서 튜플을 돌려주던 코드와 비교하면서, main의 호출 calculate_length(&s1)과 매개변수 타입 &String에 붙은 &를 보세요.

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

    let len = calculate_length(&s1);

    println!("The length of '{s1}' is {len}.");
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

The length of 'hello' is 5.

변수 선언과 반환 값에 있던 튜플이 모두 사라졌습니다. calculate_length에 s1 대신 &s1을 넘기고, 함수 정의의 매개변수 타입도 String 대신 &String이 되었습니다. 이 앰퍼샌드 &가 참조를 나타내며, 값의 소유권을 가져오지 않고 그 값을 가리키게 합니다. 다음 그림은 &String 타입의 s가 String 타입의 s1을 가리키는 모습입니다.

&로 참조를 만드는 것의 반대, 곧 참조를 따라가 그 값을 꺼내는 것을 역참조(dereferencing)라고 하며, 역참조 연산자는 *입니다. 역참조는 벡터와 값 목록에서 몇 번 쓰고 Deref와 역참조 강제 변환에서 자세히 다룹니다.

&s1은 s1의 값을 가리키지만 소유하지는 않는 참조를 만듭니다. 소유하지 않으므로 참조를 다 써도 그 참조가 가리키는 값은 버려지지 않습니다. 함수의 시그니처에서도 &로 매개변수 s가 참조라는 것을 나타냅니다.

fn calculate_length(s: &String) -> usize { // s는 String의 참조
    s.len()
} // s가 스코프를 벗어나지만, s는 가리키는 값을 소유하지 않으므로
  // 그 String은 버려지지 않음

s가 유효한 범위는 다른 매개변수와 같지만, s가 소유권을 갖지 않으므로 s를 더 이상 쓰지 않아도 가리키는 값은 버려지지 않습니다. 함수가 값 대신 참조를 매개변수로 받으면, 처음부터 소유권을 받지 않았으므로 소유권을 돌려주려고 값을 반환할 필요도 없습니다. 이렇게 참조를 만드는 것을 대여(borrowing)라고 합니다. 현실에서 남의 물건을 빌려 쓰고 다 쓰면 돌려주듯이, 빌린 값은 내 것이 아닙니다.

그러면 빌린 값을 고치려 하면 어떻게 될까요? 다음 코드는 컴파일되지 않습니다.

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

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}

error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
8 |     some_string.push_str(", world");
  |     ^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
  |
help: consider changing this to be a mutable reference
  |
7 | fn change(some_string: &mut String) {
  |                         +++

변수가 기본으로 불변인 것처럼 참조도 기본으로 불변이어서, 참조를 통해 가리키는 값을 고칠 수 없습니다. 오류 메시지는 some_string이 & 참조라 그 값을 고치는 데 쓸 수 없다고 하고, 7번째 줄의 매개변수를 &mut String으로 바꾸라는 도움말을 줍니다.

가변 참조자

조금만 고치면 빌린 값을 바꿀 수 있습니다. 가변 참조(mutable reference)를 쓰면 됩니다.

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

    change(&mut s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

먼저 s를 mut으로 바꾸고, change를 부를 때 &mut s로 가변 참조를 만들어 넘기며, 함수도 some_string: &mut String으로 가변 참조를 받게 했습니다. 이렇게 하면 change가 빌린 값을 바꾼다는 것이 코드에 분명히 드러납니다.

가변 참조에는 큰 제약이 하나 있습니다. 어떤 값의 가변 참조가 있는 동안에는 그 값의 참조를 하나도 더 만들 수 없습니다. 다음 코드는 s의 가변 참조를 두 개 만들려 하므로 컴파일되지 않습니다.

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

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{}, {}", r1, r2);
}

error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
5 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
6 |
7 |     println!("{}, {}", r1, r2);
  |                        -- first borrow later used here

E0499는 s를 한 번에 두 번 넘게 가변으로 빌릴 수 없다는 오류입니다. 첫 가변 대여는 r1에 있고 println!에서 쓰일 때까지 유지되어야 하는데, 그 사이에 r2가 같은 값을 또 가변으로 빌리려 했습니다. 대부분의 언어는 언제든 값을 바꾸게 하므로 처음에는 답답하게 느껴지지만, 이 제약 덕분에 러스트는 데이터 경쟁(data race)을 컴파일할 때 막을 수 있습니다.

데이터 경쟁은 다음 세 가지가 함께 일어날 때 생기는 경쟁 상태(race condition)입니다. 둘 이상의 포인터가 같은 데이터에 동시에 접근하고, 그 가운데 하나 이상이 데이터에 쓰며, 접근을 동기화하는 장치가 없는 경우입니다. 데이터 경쟁은 정의되지 않은 동작을 일으키고, 실행 중에 원인을 찾아 고치기가 어렵습니다. 러스트는 데이터 경쟁이 생길 수 있는 코드를 아예 컴파일하지 않습니다.

중괄호로 새 스코프를 만들면, 가변 참조를 여러 개 쓰더라도 동시에 존재하지는 않게 할 수 있습니다.

    let mut s = String::from("hello");

    {
        let r1 = &mut s;
        r1.push_str("!");
    } // r1이 여기서 스코프를 벗어나므로 새 참조를 만들어도 됨

    let r2 = &mut s;

가변 참조와 불변 참조를 섞을 때도 비슷한 규칙이 적용됩니다. 다음 코드도 컴파일되지 않습니다.

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

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    let r3 = &mut s; // BIG PROBLEM

    println!("{}, {}, and {}", r1, r2, r3);
}

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

같은 값의 불변 참조가 있는 동안에는 가변 참조도 만들 수 없습니다. 불변 참조를 쓰는 쪽은 그 값이 도중에 바뀌리라고 생각하지 않기 때문입니다. 반면 불변 참조는 여러 개여도 괜찮습니다. 데이터를 읽기만 하는 쪽은 다른 쪽이 읽는 데 영향을 주지 않기 때문입니다.

참조가 유지되는 구간은 참조를 만든 곳부터 그 참조를 마지막으로 쓰는 곳까지입니다. 변수가 선언된 블록 전체가 아니라는 점이 중요합니다. 다음 코드는 불변 참조를 마지막으로 쓰는 첫 println! 뒤에 가변 참조를 만들므로 컴파일됩니다.

    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{r1} and {r2}");
    // r1과 r2는 이 뒤로 쓰이지 않음

    let r3 = &mut s; // no problem
    println!("{r3}");

r1과 r2라는 이름은 블록 끝까지 남아 있지만, 두 불변 참조는 첫 println!에서 마지막으로 쓰였으므로 그 뒤로는 대여가 끝난 것으로 봅니다. 그래서 r3의 가변 대여와 겹치지 않습니다. 컴파일러는 참조가 스코프 끝보다 앞에서 더 이상 쓰이지 않는다는 것을 알아낼 수 있으며, 아래 그림이 이 과정을 보여 줍니다.

r1과 r2가 s를 함께 빌리는 동안에는 읽기만 할 수 있습니다. 두 참조를 더 이상 쓰지 않으면 활성인 대여가 없어지고, 그때 r3로 같은 s를 가변으로 빌려 고칠 수 있습니다. 반대로 r3를 만든 뒤에 r1을 다시 쓰는 코드라면, 공유 대여가 그때까지 이어지므로 E0502 오류로 거부됩니다.

이런 대여 오류는 답답할 수 있지만, 러스트 컴파일러가 숨어 있는 오류를 실행 전에 미리 찾아 정확히 어디가 문제인지 알려 주는 것입니다. 데이터가 왜 예상과 다른지 실행 중에 하나하나 추적할 필요가 없어집니다.

더 깊이: 대여 검사기가 마지막 사용을 보게 된 과정

참조가 유지되는 구간을 블록 끝이 아니라 마지막 사용까지로 보는 지금의 대여 검사를 NLL(non-lexical lifetimes)이라고 부릅니다. 이름 그대로, 참조의 구간을 변수가 선언된 블록이라는 어휘적 범위(lexical scope)에 묶지 않는다는 뜻입니다. 러스트 블로그에 따르면 NLL은 Rust 2018 에디션과 함께 그 에디션의 코드에만 먼저 켜졌고, 2015 에디션의 코드는 옛 검사기와 새 검사기를 함께 돌려 결과를 비교하는 이행 모드로 검사되었습니다. Rust 1.63부터는 모든 코드가 NLL로만 검사됩니다.

마지막 사용만으로는 설명되지 않는 경우도 있습니다. v.push(v.len())은 push를 부르려고 v를 가변으로 빌린 채 인수에서 v.len()으로 v를 다시 읽는 것처럼 보이지만 컴파일됩니다. 러스트 컴파일러 개발 안내서는 이것을 2단계 대여(two-phase borrow)로 설명합니다. 메서드를 부를 때 자동으로 만드는 가변 대여 같은 몇몇 암묵적인 가변 대여는, 먼저 예약(reservation)되어 공유 대여처럼 동작하다가 실제로 함수가 불리는 시점에 활성화(activation)되어 가변 대여가 됩니다. 직접 쓴 &mut에는 이 규칙이 적용되지 않으므로, let r = &mut v; 다음에 v.len()을 읽고 다시 r을 쓰는 코드는 여전히 거부됩니다.

댕글링 참조

포인터가 있는 언어에서는 댕글링 포인터(dangling pointer)를 만들기 쉽습니다. 메모리를 해제했는데 그 메모리를 가리키는 포인터가 남아 있어, 그 메모리가 다른 곳에 쓰인 뒤에도 그 포인터로 접근할 수 있는 상태입니다. 러스트에서는 컴파일러가 참조가 댕글링 참조가 되지 않도록 보장합니다. 어떤 데이터의 참조가 있으면, 그 참조를 쓰는 동안 데이터가 먼저 스코프를 벗어나지 않는지 컴파일러가 확인합니다. 댕글링 참조를 만들어 보면 컴파일러가 어떻게 막는지 알 수 있습니다.

fn main() {
    let reference_to_nothing = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");

    &s
}

error[E0106]: missing lifetime specifier
 --> src/main.rs:5:16
  |
5 | fn dangle() -> &String {
  |                ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from

이 메시지에는 아직 다루지 않은 라이프타임(lifetime)이라는 기능이 나오며, 라이프타임은 라이프타임과 참조 유효성에서 자세히 다룹니다. 라이프타임 부분을 빼고 보면, 이 함수의 반환 타입은 빌린 값을 담고 있는데 빌려 올 값이 없다는 도움말이 핵심입니다. 그 뒤에는 참조 대신 소유한 값을 돌려주라는 도움말도 이어집니다. dangle 안에서 무슨 일이 일어나는지 차례로 보면 다음과 같습니다.

fn dangle() -> &String { // dangle은 String의 참조를 돌려줌

    let s = String::from("hello"); // s는 새 String

    &s // String s의 참조를 돌려줌
} // 여기서 s가 스코프를 벗어나 버려지고, 그 메모리가 해제됨

s는 dangle 안에서 만들어졌으므로 dangle이 끝나면 해제됩니다. 그런데 &s를 돌려주려 했으니, 해제된 String을 가리키는 참조를 돌려주는 셈입니다. 러스트는 이것을 허용하지 않습니다. 이런 경우에는 참조 대신 String을 그대로 돌려주면 됩니다.

fn no_dangle() -> String {
    let s = String::from("hello");

    s
}

이 코드는 아무 문제 없이 동작합니다. 소유권이 함수 밖으로 이동하므로, 함수가 끝날 때 아무것도 해제되지 않습니다.

참조자 규칙

참조에 대해 배운 내용을 정리하면 다음 두 규칙입니다.

• 어느 시점이든, 한 값에 대해 가변 참조 하나만 있거나 불변 참조 여러 개만 있을 수 있습니다.
• 참조는 언제나 유효해야 합니다.

아래 표는 같은 값을 빌리는 여러 경우를 정리한 것입니다. 기준은 참조 변수의 개수가 아니라, 같은 값을 빌리는 구간이 실제로 쓰이는 동안 겹치는지와, 그 구간 내내 빌린 값이 유효한지입니다.

불변 참조가 여럿이면 모두 읽기만 하며 원래 변수가 계속 소유합니다. 가변 참조가 하나면 그 참조로 읽고 쓸 수 있지만 그동안 같은 값에 다른 접근은 할 수 없고, 소유권은 여전히 원래 변수에 있습니다. 쓰이는 구간이 겹치는 가변 대여와 다른 대여는 E0499나 E0502로 거부되며, 지역 값을 가리키는 참조를 돌려주려 하면 E0106으로 거부됩니다. 더 자세한 규칙은 공식 Book의 References and Borrowing과 Reference의 Borrow operators에 있습니다.

정리

• 참조는 값을 소유하지 않고 가리키며, &로 만들고 참조를 만드는 것을 대여라고 합니다.
• 참조는 기본으로 불변이어서 가리키는 값을 고칠 수 없고, 고치려면 &mut으로 가변 참조를 만듭니다.
• 한 값에 대해서는 가변 참조 하나나 불변 참조 여러 개만 동시에 있을 수 있으며, 이 규칙이 데이터 경쟁을 막습니다.
• 참조가 유지되는 구간은 그 참조를 마지막으로 쓰는 곳까지이므로, 마지막 사용 뒤에는 다른 대여를 할 수 있습니다.
• 러스트는 참조가 가리키는 값보다 오래 쓰이는 댕글링 참조를 컴파일할 때 거부하며, 함수 안에서 만든 값은 참조 대신 그대로 돌려줍니다.

연습 문제

1. 마지막 사용 뒤에 고치기

다음 프로그램은 무엇을 출력하나요? 맨 끝에 println!("again={read}");를 더하면 어떻게 되나요?

fn main() {
    let mut s = String::from("spring");
    let read = &s;
    println!("before={read}");

    let edit = &mut s;
    edit.push_str("time");
    println!("after={edit}");

    println!("owner={s}");
}

2. 고칠 수 있는 참조인가

다음 함수 가운데 컴파일되는 것은 무엇인가요? (가) fn add_one(v: &Vec<i32>) { v.push(1); } (나) fn add_one(v: &mut Vec<i32>) { v.push(1); } (다) fn first_len(v: &Vec<String>) -> usize { v[0].len() }

3. 참조를 돌려줄 수 있을 때

fn longest_name() -> &String은 E0106 오류로 컴파일되지 않았습니다. 같은 일을 하는 함수를 컴파일되게 만드는 방법 두 가지를 들어 보세요.

다음 글 슬라이스에서는 컬렉션 전체가 아니라 그 안의 연속된 일부를 가리키는 또 다른 참조인 슬라이스를 살펴봅니다.