Rust의 스마트 포인터

스마트 포인터

• 값을 힙에 할당하기 위한 Box<T>

• 복수개의 소유권을 가능하게 하는 참조 카운팅 타입인 Rc<T>

• 빌림 규칙을 컴파일 타임 대신 런타임에 강제하는 타입인, RefCell<T>를 통해 접근 가능한 Ref<T>와 RefMut<T>

Box<T>

Needs

• 컴파일 타임에 크기를 알 수 없는 타입을 갖고 있고, 정확한 사이즈를 알 필요가 있는 맥락 안에서 해당 타입의 값을 이용하고 싶을 때

• 커다란 데이터를 가지고 있고 소유권을 옮기고 싶지만 그렇게 했을 때 데이터가 복사되지 않을 것이라고 보장하기를 원할 때 → 보통 포인터를 사용하는 이유

• 어떤 값을 소유하고 이 값의 구체화된 타입을 알고 있기보다는 특정 트레잇을 구현한 타입이라는 점만 신경 쓰고 싶을 때

정확한 사이즈

enum List {
    Cons(i32, List),
    Nil,
}

fn main() {
    let list = Cons(1, Cons(2, Cons(3, Nil)));//Err!!
}

• c++에서 스택 크기 설정

enum List {
    Cons(i32, Box<List>),//use box
    Nil,
}
use List::{Cons, Nil};

fn main() {
    let list = Cons(1,
     Box::new(Cons(2,
      Box::new(Cons(3,
       Box::new(Nil))))));//inner enum values are in heap
}

Deref 트레잇

fn main() {
    let x = 5;
    let y = &x;
    let z = *y;//Dereference

    println!("x: {}", x); //x: 5
    println!("y: {}", y); //y: 5
    println!("z: {}", z); //z: 5

    assert_eq!(5, x);
    assert_eq!(5, y);//no implementation for `{integer} == &{integer}`
    assert_eq!(5, z);
}

fn main() {
    let x = 5;
    let y = Box::new(x);

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

역참조 강제

fn main() {
    let x = 5;
    let y = &x;

    println!("x: {}", x); //x: 5
    println!("y: {}", y); //y: x의 주소값? or 5?

    assert_eq!(5, x);
    assert_eq!(5, y);//no implementation for `{integer} == &{integer}`
}

Drop(소멸자 정의)

struct CustomSmartPointer {
    data: String,
}

//Drop trait을 이용하여 소멸자를 정의한다.
impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer { data: String::from("my stuff") };
    let d = CustomSmartPointer { data: String::from("other stuff") };
    println!("CustomSmartPointers created.");
}

/*--------------------출력-----------------------------*/
// CustomSmartPointers created.
// Dropping CustomSmartPointer with data `other stuff`! 소멸자와 같은 역할을 함
// Dropping CustomSmartPointer with data `my stuff`! 스택 영역이므로  Last in First out

강제적 소멸

fn main() {
    let c = CustomSmartPointer { data: String::from("some data") };
    println!("CustomSmartPointer created.");
    c.drop(); //Err!!
    println!("CustomSmartPointer dropped before the end of main.");
}

fn main() {
    let c = CustomSmartPointer { data: String::from("some data") };
    println!("CustomSmartPointer created.");
    drop(c);//c의 drop을 호출!
    println!("CustomSmartPointer dropped before the end of main.");
}//c의 drop이 발생되지 않음

/*--------------------출력-------------------------*/
// CustomSmartPointer created.
// Dropping CustomSmartPointer with data `some data`!
// CustomSmartPointer dropped before the end of main.

Rc (Reference Count)

CBase::CBase()
 : m_dwRefCnt(0)
{

}

_ulong CBase::AddRef()
{
 return ++m_dwRefCnt;
}

_ulong CBase::Release()
{
 if (0 == m_dwRefCnt)
 {
  Free();

  delete this;

  return 0;
 }

 else
  return m_dwRefCnt--;

}

• 참조할 때 마다 레퍼런스 카운트를 증가를 시킨다.

• 참조를 해제할 때 마다 레퍼런스 카운트를 감소시킨다.

• 레퍼런스 카운트가 0이되면 자신을 삭제시킨다.

fn main() {
    let a = Rc::new(10);//ref:1
    println!("count after creating a = {}", Rc::strong_count(&a));//1
    let b = Rc::clone(&a);//ref ++
    println!("count after creating b = {}", Rc::strong_count(&a));//2
    {
        let c = a.clone();//ref++
        println!("count after creating c = {}", Rc::strong_count(&a));//3
    }//ref--
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));//2
}

RefCell

fn main() {
    let mut a = 10;
    let b = &a;
    let c = &mut a;//Err!
}

fn main() {
    let a = Rc::new(10);
    let b = a.clone();
    *b = 4;//Err
}

fn main() {
    let a = Rc::new(RefCell::new(10));
    let b = a.clone();
    *b.borrow_mut() = 4;
}