반응형

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

 

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

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/

 

2022. 10. 24  최초작성



참조자

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

 

Rust는 참조자가 데이터를 소유하고 있는 변수보다 더 오래 존재하지 않도록 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에 대한 참조임을 나타냅니다. 
fn calculate_length(s: &String) -> usize {

  
    // 메소드 len을 사용하여 계산된 문자열의 길이를 자신을 호출한 곳에 전달합니다.
    s.len()


    // 함수 범위를 벗어나는 순간 참조자 s는 삭제됩니다. 
    // s는 변수 s1에 대한 참조자이기 때문에 변수 s1이 가리키는 데이터에 대한 소유권을 가지지 않습니다. 
    // 따라서 함수가 종료되면서 참조자 s가 삭제되더라도 참조자 s가 가리키는 데이터인 변수 s1의 값이 삭제되지 않습니다.
}

 

실행결과

The length of 'hello' is 5.

 

다음 코드처럼 참조자 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);

    let r3 = &mut s;
    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
}

 

실행결과

 

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

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;

    let immutable_raw_pointer = &value as *const i32;
    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 };
    let ref_ref_ref_f = &f;


    // . 연산자가 자동으로 역참조 했기 때문에 *를 안적어도 됩니다. 
    println!("{}", ref_ref_ref_f.value);

    // 원래는 다음처럼 *를 적어줘야 합니다.
    println!("{}", (*ref_ref_ref_f).value);
}

 

실행결과

42
42



반응형

진행해본 결과물을 기록 및 공유하는 공간입니다.
잘못된 부분이나 개선점을 알려주시면 반영하겠습니다.


소스코드 복사시 하단에 있는 앵커 광고의 왼쪽 위를 클릭하여 닫은 후 해야 합니다.


문제가 생기면 포스트와 바뀐 환경이 있나 먼저 확인해보세요.
질문을 남겨주면 가능한 빨리 답변드립니다.


제가 쓴 책도 한번 검토해보세요 ^^

  • 네이버 블러그 공유하기
  • 네이버 밴드에 공유하기
  • 페이스북 공유하기
  • 카카오스토리 공유하기

댓글을 달아 주세요

TistoryWhaleSkin3.4">