간단하게 정리해본 Rust 강좌 8 : 참조자, 댕글링 참조, 원시 포인터

간단하게 정리해본 Rust 강좌입니다. 

 

 

2022. 10. 24  최초작성

2023. 4. 26 최종작성

Rust 개발 환경 만드는 방법은 아래 포스트를 참고하세요.

https://webnautes.tistory.com/2110

 

참조자

Rust의 참조자는 특정 주소에 저장된 데이터에 액세스하기 위한 메모리 상의 시작 주소라는 점에서 C/C++의 포인터와 똑같습니다.  참조자는 데이터를 소유하고 있지 않으며 다른 변수가 소유하고 있는 데이터를 가리키고 있습니다. 

 

참조자가 데이터를 소유하고 있는 변수보다 더 오래 존재하지 않도록 lifetime을 검증합니다. 또한 참조자를 사용하는 동안에는 참조자가 가리키고 있는 데이터를 액세스 할 수 있도록 보장해줍니다. 

 

다음 코드는 변수의 소유권을 가져오는 대신 파라미터로 변수에 대한 참조자를 가져오는 compute_length 함수를 정의하고 사용하는 예제입니다.

 

fn main() {     let s1 = String::from("hello");     // 변수 s1에 대한 참조자인 &s1을 calculate_length 함수에 전달합니다.     // &는 참조를 나타내며 소유권 없이 값을 빌리는 것을 의미합니다.      let len = calculate_length(&s1);     println!("The length of '{}' is {}.", s1, len); } // 파라미터의 데이터 타입으로 &가 붙은 &String을 사용하여 데이터 타입 String에 대한 참조임을 나타냅니다. // 문자열의 길이를 리턴하기 때문에 리턴하는 값의 데이터 타입은 usize입니다.    fn calculate_length(s: &String) -> usize {        // 메소드 len을 사용하여 계산된 문자열의 길이를 자신을 호출한 곳에 전달합니다.      s.len()     // 함수 범위를 벗어나는 순간 참조자 s는 삭제됩니다.      // s는 main 함수에 있는 변수 s1에 대한 참조자이기 때문에 변수 s1이 가리키는 데이터에 대한 소유권을 가지지 않습니다.      // 따라서 함수가 종료되면서 참조자 s가 삭제되더라도 참조자 s가 가리키는 데이터인 변수 s1의 값이 삭제되지 않습니다. }

실행결과

The length of 'hello' is 5.

다음 코드처럼 calculate_length 함수에서 참조자 s의 값을 변경하려고 하면 다음 에러가 발생합니다. 

error[E0596]: cannot borrow `*s` as mutable, as it is behind a `&` reference

 

fn main() {     let s1 = String::from("hello");     let len = calculate_length(&s1);          println!("The length of '{}' is {}.", s1, len); } fn calculate_length(s: &String) -> usize {        s.push_str(" world");     s.len() }

실행 결과

변수가 기본적으로 값을 변경할수 없는 것처럼 참조자도 가리키고 있는 값을 수정할 수 없습니다.

하지만 다음처럼 참조자에 mut 키워드를 추가하면 참조자가 가리키는 값을 수정할 수 있습니다.

fn main() {     let mut s1 = String::from("hello");     let len = calculate_length(&mut s1);     println!("The length of '{}' is {}.", s1, len); } fn calculate_length(s: &mut String) -> usize {        s.push_str(" world");     s.len() }

다음 코드처럼 하나의 변수 s에 대해 값 변경이 가능한 참조자 2개를 생성하면 에러가 발생합니다. 

error[E0499]: cannot borrow `s` as mutable more than once at a time

 

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

실행 결과

Rust는 컴파일 시간에 데이터 경합을 방지할 수 있습니다.  데이터 경합은 다음 세 가지 동작이 발생할 때 발생합니다.Rust는 데이터 경합으로 코드를 컴파일하는 것을 거부함으로써 이 문제를 방지합니다!

• 두 개 이상의 포인터가 동시에 동일한 데이터에 액세스합니다.
• 포인터 중 하나 이상이 데이터의 값을 변경하려고 합니다. 
• 데이터에 대한 액세스를 동기화하는 데 사용되는 메커니즘이 없습니다.

중괄호 {} 를 사용하여 새로운 범위를 생성한 경우에는  변경 가능한 여러 개의 참조자를 사용할 수 있습니다. 

fn main() {     let mut s = String::from("hello");     {         // r1은 새로운 범위내에 있으므로 문제 없이 변경가능한 새로운 참조자를 만들 수 있습니다.         let r1 = &mut s;         r1.push_str(" world");     }        let r2 = &mut s;     r2.push_str(" rabbit");     println!("{}", s); }

실행결과

hello world rabbit

변경 불가능한 참조자가 있는 동안에는 변경 가능한 참조자를 생성할 수 없습니다. 

다음 코드는 에러를 발생시킵니다. 

error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable

 

fn main() {     let mut s = String::from("hello");     let r1 = &s;  // 변경 불가능한 참조자입니다.     let r2 = &s;  // 변경 불가능한 참조자를 또 생성하는 건 문제 없습니다.     let r3 = &mut s; // 변경 가능한 참조자를 생성하려고 하면 문제가 발생합니다.      println!("{}, {}, and {}", r1, r2, r3); }

실행결과

참조의 범위는 참조자가 시작된 곳에서 시작하여 참조자가 마지막으로 사용될 때까지만 지속됩니다.  다음 예제 코드에서 변경 불가능한 참조자인 r1, r2를 마지막으로 사용한 println문 다음에 변경 가능한 참조자를 생성하기 때문에 에러가 발생하지 않습니다. 

fn main() {     let mut s = String::from("hello");     let r1 = &s;      let r2 = &s;     println!("{} and {}", r1, r2);  // 변경 불가능한 참조자 r1, r2가 마지막으로 사용되었습니다.     let r3 = &mut s; // 더 이상 변경 불가능한 참조가 r1,r2가 사용되지 않기 때문에 변경 가능한 참조자를 생성할 수 있습니다.     println!("{}", r3); }

실행결과

hello and hello

hello

댕글링 참조(Dangling References)

포인터가 있는 언어에서는 메모리를 가리키는 포인터가 존재하는 상황에서  메모리에 있는 값이 삭제된 댕글링 포인터를 생성하는 상황이 생길 수 있습니다.  

Rust에서는 컴파일 타임 에러로 댕글링 포인터를 방지해줍니다. Rust에서는 댕글링 포인터를 댕글링 참조라고 합니다.  

 

다음 코드는 댕글링 참조가 발생하는 상황에 에러가 발생합니다. 

error[E0106]: missing lifetime specifier

 

fn main() {     // 이미 함수 dangle에서 변수 s의 값이 삭제되었기 때문에 참조할 값이 없습니다.      let reference_to_nothing = dangle();     println!("{}", reference_to_nothing); } fn dangle() -> &String {     let s = String::from("hello");     // dangle 함수가 종료되면 값이 삭제되는 변수 s의 값을 참조로 리턴합니다.      &s }

실행결과

no_dangle 함수에서 다음처럼 변수에 대한 참조자 &s 대신 변수 s를 반환하여 문제를 해결할 수 있습니다. 

fn main() {     let reference_to_nothing = no_dangle();     println!("{}", reference_to_nothing); } fn no_dangle() -> String {     let s = String::from("hello");     s }

실행결과

hello

원시 포인터(Raw Pointers)

원시 포인터를 사용하는 경우에는 Rust는 원시 포인터가 가리키는 위치가 유효한지 체크해주지 않습니다. 

 

원시 포인터에는 다음 두 종류가 있습니다:

*const T - 자료형 T의 데이터를 가리키는 변경되지 않는 원시 포인터

*mut T - 자료형 T의 데이터를 가리키는 변경될 수 있는 원시 포인터

 

원시 포인터를 사용할 경우 기억해야할 사항입니다. 

• 유효한 메모리를 가리키도록 보장되지 않으며 NULL이 아니라는 보장도 없습니다
• 수동 리소스 관리가 필요합니다.
• 소유권을 이전하지 않습니다. 따라서 use-after-free와 같은 버그로부터 보호할 수 없습니다.
• 참조와 달리 수명관리가 없습니다. 

 

다음처럼 원시 포인터를 생성할 수 있습니다. 

fn main() {     // 변경 불가능한 원시 포인터     let x = 5;     let raw = &x as *const i32;     // 변경 가능한 원시 포인터      let mut y = 10;     let raw_mut = &mut y as *mut i32; }

역참조하는 경우에는 unsafe 키워드를 사용하여 블록으로 깜싸주어야 합니다. 

원시 포인터를 역참조할 때 잘못된 위치를 가리키지 않는다는 것을 체크해야 합니다.  

 

fn main() {     let x = 5;     // 원시 포인터     let raw = &x as *const i32;     // 역참조     let points_at = unsafe { *raw };          println!("raw points at {}", points_at);     }

 

실행결과

raw points at 5

 

하나의 변수에 대해 변경 불가능한 원시 포인터와 변경 가능한 원시 포인터를 생성할 수 있습니다. 

fn main() {     let mut value = 10;     // 변수 value에 대한 변경 불가능한 원시 포인터     let immutable_raw_pointer = &value as *const i32;     // 변수 value에 대한 변경 가능한 원시 포인터     let mutable_raw_pointer = &mut value as *mut i32;     unsafe {         // 원시 포인터를 역참조하려면 unsafe 블럭 내에서 해야 합니다.          // immutable_raw_pointer와 달리 mutable_raw_pointer는 값을 변경할 수 있습니다.          *mutable_raw_pointer = *mutable_raw_pointer + 1;                  println!("value is: {}", *immutable_raw_pointer);         println!("value is: {}", *mutable_raw_pointer);     }        }

실행결과

value is: 11

value is: 11

참조와 원시 포인터간 변환

fn main() {     // 참조를 원시 포인터로 명시적 변환     let i: u32 = 1;     let p_1: *const u32 = &i as *const u32;               // 참조를 원시 포인터로 암시적 변환     let m: u32 = 2;     let p_2: *const u32 = &m;          unsafe {         // 역참조(*) 연산자를 사용하여 원시 포인터의 값을 출력         println!("{}", *p_1);         println!("{}", *p_2);         // 원시 포인터를 참조로 변환         let ref_1: &u32 = &*p_1;         let ref_2: &u32 = &*p_2;         // 참조의 값을 출력         println!("{}", ref_1);         println!("{}", ref_2);     }        }

실행 결과

1

2

1

2

. 연산자

. 연산자는 참조하는 객체의 멤버 변수와 메소드에 접근하는 데에 쓰입니다. 

 

struct Foo {     value: i32 } fn main() {     let f = Foo { value: 42 };     // 변수 f에 대한 참조자입니다.      let ref_ref_ref_f = &f;     // . 연산자가 자동으로 역참조 했기 때문에 *를 안적어도 됩니다.      println!("{}", ref_ref_ref_f.value);     // 원래는 다음처럼 *를 적어줘야 합니다.      println!("{}", (*ref_ref_ref_f).value); }

실행결과

42

42

다음 문서를 기반으로 작성했습니다.

https://tourofrust.com/00_ko.html 

https://doc.rust-lang.org/1.30.0/book/first-edition/raw-pointers.html 

https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html 

https://blog.knoldus.com/raw-pointers-in-unsafe-rust-are-quite-powerful/

 

 

간단하게 정리해본 Rust 강좌 1 : 변수, 상수, 함수, 튜플, 배열, 데이터타입, println

https://webnautes.tistory.com/2194

 

간단하게 정리해본 Rust 강좌 2 : if-else, loop, while, for, match, struct, method

https://webnautes.tistory.com/2195

 

간단하게 정리해본 Rust 강좌 3 : 열거형, 제네릭 데이터 타입, Option, Result, unwrap, vector

https://webnautes.tistory.com/2196

 

간단하게 정리해본 Rust 강좌 4 : 소유권, 참조, 역참조, 생명주기

https://webnautes.tistory.com/2197

 

간단하게 정리해본 Rust 강좌 5 : 문자열, utf-8

https://webnautes.tistory.com/2198

 

간단하게 정리해본 Rust 강좌 6 : 모듈

https://webnautes.tistory.com/2199

 

간단하게 정리해본 Rust 강좌 7 : &self, &mut self, trait, 동적 디스패치, 정적 디스패치, Generic 메서드, Box

https://webnautes.tistory.com/2200

 

간단하게 정리해본 Rust 강좌 8 : 참조자, 댕글링 참조, 원시 포인터

https://webnautes.tistory.com/2203

 

간단하게 정리해본 Rust 강좌 9 : Box, 재귀적 데이터타입, Deref 트레잇

https://webnautes.tistory.com/2202