Rust 학습 노트 (4) - 잠시 빌려쓰는 변수, borrow

함수에 값을 한 번 넘기면 호출자는 다시 그 값을 쓸 수 없습니다. 그러나, 두 변수가 같은 데이터를 동시에 들여다볼 일은 일반적으로 너무나 필요합니다.

예시

fn print_message(s: String) {
    println!("{}", s);
}

let message = String::from("hello");
print_message(message);
println!("{}", message);  // 컴파일 에러

error[E0382]: borrow of moved value: `message`
 --> main.rs:8:20
  |
6 |     let message = String::from("hello");
  |         ------- move occurs because `message` has type `String`, which does not implement the `Copy` trait
7 |     print_message(message);
  |                   ------- value moved here
8 |     println!("{}", message);  // 컴파일 에러
  |                    ^^^^^^^ value borrowed here after move
  |
note: consider changing this parameter type in function `print_message` to borrow instead if owning the value isn't necessary
 --> main.rs:2:25
  |
2 |     fn print_message(s: String) {
  |        -------------    ^^^^^^ this parameter takes ownership of the value
  |        |
  |        in this function
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
  |
7 |     print_message(message.clone());
  |                          ++++++++

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0382`.

function printMessage(s) {
  console.log(s);
}

const message = "hello";
printMessage(message);
console.log(message);  // 멀쩡히 동작

& 한 글자가 하는 일

fn print_message(s: &String) {
    println!("{}", s);
}

let message = String::from("hello");
print_message(&message);
println!("{}", message);  // 멀쩡히 동작합니다.

let message = String::from("hello");
                   │
                   │  message가 heap "hello"의 주인
                   ▼
              ┌─────────┐
              │ "hello" │
              └─────────┘
                   ▲
                   │
print_message(&message);
                   │
                   └── &로 만든 표지가 함수에 넘어감.
                       소유권은 그대로 message에게 있음.

잠깐, 그러면 i32 같은 값은 왜 안 막혔는가

fn double(n: i32) -> i32 {
    n * 2
}

let x = 10;
double(x);
println!("{}", x);  // 멀쩡히 동작

message has type String, which does not implement the Copy trait

빌리는 동안 주인은 어디에 있는가

let mut v = vec![1, 2, 3];
let first = &v[0];     // v를 빌려서 첫 요소를 가리킴

v.push(4);             // 컴파일 에러

println!("{}", first);

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
  --> main.rs:20:5
   |
18 |     let first = &v[0];     // v를 빌려서 첫 요소를 가리킴
   |                  - immutable borrow occurs here
19 |
20 |     v.push(4);             // 컴파일 에러
   |     ^^^^^^^^^ mutable borrow occurs here
21 |
22 |     println!("{}", first);
   |                    ----- immutable borrow later used here

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0502`.

두 종류의 빌림: &와 &mut

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

let r1 = &s;           // immutable borrow: 읽기만 가능
let r2 = &s;           // 또 다른 immutable borrow도 OK
println!("{} {}", r1, r2);

let r3 = &mut s;       // mutable borrow: 변경까지 가능
r3.push_str(", world");
println!("{}", r3);

컴파일러가 막아서는 순간

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

let r1 = &s;
let r2 = &mut s;       // 컴파일 에러

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

  --> main.rs:38:27
   |
37 |     let r1: &String = &s;
   |                       -- immutable borrow occurs here
38 |     let r2: &mut String = &mut s;       // 컴파일 에러
   |                           ^^^^^^ mutable borrow occurs here
39 |
40 |     println!("{} {}", r1, r2);
   |                       -- immutable borrow later used here

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0502`.

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
  --> main.rs:49:14
   |
48 |     let r1 = &mut s;
   |              ------ first mutable borrow occurs here
49 |     let r2 = &mut s;       // 컴파일 에러
   |              ^^^^^^ second mutable borrow occurs here
50 |
51 |     println!("{} {}", r1, r2);
   |                       -- first borrow later used here

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0499`.

잠깐, 그러면 동시에 못 쓰는 것 아닌가

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

let r1 = &s;
let r2 = &s;
println!("{} {}", r1, r2);
// r1과 r2는 여기까지만 사용됨

let r3 = &mut s;
r3.push_str(", world");
println!("{}", r3);

마무리

참고 자료

• The Rust Programming Language - References and Borrowing

• Rust Reference - References

• Rust 2018: Non-Lexical Lifetimes

• Rust 학습 노트 (3) - Rust는 매 순간이 소유권 분쟁이다