[Rust] & 대신 ref를 쓰는 이유

ref 와 & 는 같은 표현이다. 아래 코드에서도 첫 번째는 ref 를 사용하고 두 번째는 & 를 사용했지만 결국 같은 의미다. 같은 의미인데 굳이 다른 표현이 존재하는 이유는 무엇일까?

let c = 'Q';

let ref ref_c1 = c;
let ref_c2 = &c;

전체 예제코드

---

#[derive(Clone, Copy)]
struct Point { x: i32, y: i32 }

fn main() {
    let c = 'Q';

    // A `ref` borrow on the left side of an assignment is equivalent to
    // an `&` borrow on the right side.
    let ref ref_c1 = c;
    let ref_c2 = &c;

    println!("ref_c1 equals ref_c2: {}", *ref_c1 == *ref_c2);

    let point = Point { x: 0, y: 0 };

    // `ref` is also valid when destructuring a struct.
    let _copy_of_x = {
        // `ref_to_x` is a reference to the `x` field of `point`.
        let Point { 
        	x: ref ref_to_x, 
            y: _ 
        } = point;

        // Return a copy of the `x` field of `point`.
        *ref_to_x
    };

    // A mutable copy of `point`
    let mut mutable_point = point;

    {
        // `ref` can be paired with `mut` to take mutable references.
        let Point { 
        	x: _, 
        	y: ref mut mut_ref_to_y 
        } = mutable_point;

        // Mutate the `y` field of `mutable_point` via a mutable reference.
        *mut_ref_to_y = 1;
    }

    println!("point is ({}, {})", point.x, point.y);
    println!("mutable_point is ({}, {})", mutable_point.x, mutable_point.y);

    // A mutable tuple that includes a pointer
    let mut mutable_tuple = (Box::new(5u32), 3u32);
    
    {
        // Destructure `mutable_tuple` to change the value of `last`.
        let (_, ref mut last) = mutable_tuple;
        *last = 2u32;
    }
    
    println!("tuple is {:?}", mutable_tuple);
}

1. Pattern matching에서 reference를 사용할 때

코드의 중간 부분을 보면

    let point = Point { x: 0, y: 0 };

    // `ref` is also valid when destructuring a struct.
    let _copy_of_x = {
        // `ref_to_x` is a reference to the `x` field of `point`.
        let Point { 
        	x: ref ref_to_x, 
            y: _ 
        } = point;

        // Return a copy of the `x` field of `point`.
        *ref_to_x
    };

point 를 다시 destruct하면서 point.x 값을 ref 로 받아오고 있다. 위 상황처럼 pattern matching 할 때 reference 값으로 받아오고 싶다면 & 기호가 아닌 ref 를 적어줘야 한다.

2. reference 타입이 아닌 변수를 참조값으로 받고 싶을 때

 let mut mutable_point = point;

    {
        let Point { 
        	x: _, 
        	y: ref mut mut_ref_to_y 
        } = mutable_point;

       
        *mut_ref_to_y = 1;
    }

mutable_point 는 현재 앞에 mut 을 사용해줘서 muttable 한 변수이다. 위 코드는 destructing 할 때 muttable과 reference를 동시에 사용하고 싶어하는데, 이미 reference 타입인 변수에는 & 기호를 붙여도 되지만 reference 타입이 아닌 경우에는 & 기호를 붙일 수 없고, 반드시 ref 를 적어줘야 한다.


따라서 아래와 같이 사용할 수 없다.

y: &mut mut_ref_to_y //틀린 표현!!