[Rust] study Smart Pointers

1
2
3
4
5
fn main() {
    let a = 42;
    let memory_location = &a as *const i32 as usize;
    println!("데이터는 여기 있습니다: {}", memory_location);
}

1
2
3
4
5
6
7
fn main() {
    let a: i32 = 42;
    let ref_ref_ref_a: &&&i32 = &&&a;
    let ref_a: &i32 = **ref_ref_ref_a;
    let b: i32 = *ref_a;
    println!("{}", b)
}

1
2
3
4
5
6
7
8
9
struct Foo {
    value: i32
}

fn main() {
    let f = Foo { value: 42 };
    let ref_ref_ref_f = &&&f;
    println!("{}", ref_ref_ref_f.value);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
use std::ops::Deref;
struct TattleTell<T> {
    value: T,
}
impl<T> Deref for TattleTell<T> {
    type Target = T;
    fn deref(&self) -> &T {
        println!("{} was used!", std::any::type_name::<T>());
        &self.value
    }
}
fn main() {
    let foo = TattleTell {
        value: "secret message",
    };
    // foo가 `len` 함수를 위해 자동참조된 후
    // 여기서 역참조가 즉시 일어납니다
    println!("{}", foo.len());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn main() {
    let a: [u8; 4] = [86, 14, 73, 64];
    // 이게 원시 pointer입니다.
    // 무언가의 메모리 주소를 숫자로 가져오는 것은 완전히 안전한 일입니다
    let pointer_a = &a as *const u8 as usize;
    println!("데이터 메모리 주소: {}", pointer_a);
    // 숫자를 원시 pointer로, 다시 f32로 변환하는 것 역시
    // 안전한 일입니다.
    let pointer_b = pointer_a as *const f32;
    let b = unsafe {
        // 이건 unsafe한데,
        // 컴파일러에게 우리의 pointer가 유효한 f32라고 가정하고
        // 그 값을 변수 b로 역참조 하라고 하고 있기 때문입니다.
        // Rust는 이런 가정이 참인지 검증할 방법이 없습니다.
        *pointer_b
    };
    println!("맹세하건대 이건 파이다! {}", b);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
use std::alloc::{alloc, Layout};
use std::ops::Deref;

struct Pie {
    secret_recipe: usize,
}

impl Pie {
    fn new() -> Self {
        // 4 바이트를 요청해 봅시다
        let layout = Layout::from_size_align(4, 1).unwrap();

        unsafe {
            // 메모리 위치를 숫자로 할당하고 저장합니다
            let ptr = alloc(layout) as *mut u8;
            // pointer 연산을 사용해 u8 값 몇 개를 메모리에 써봅시다
            ptr.write(86);
            ptr.add(1).write(14);
            ptr.add(2).write(73);
            ptr.add(3).write(64);

            Pie {
                secret_recipe: ptr as usize,
            }
        }
    }
}
impl Deref for Pie {
    type Target = f32;
    fn deref(&self) -> &f32 {
        // secret_recipe pointer를 f32 raw pointer로 변환합니다
        let pointer = self.secret_recipe as *const f32;
        // 역참조 하여 &f32 값으로 리턴합니다
        unsafe { &*pointer }
    }
}
fn main() {
    let p = Pie::new();
    // Pie struct의 smart pointer를 역참조 하여
    // "파이를 만듭니다"
    println!("{:?}", *p);
}

1
2
3
4
5
6
7
8
9
10
11
12
struct Pie;

impl Pie {
    fn eat(&self) {
        println!("heap에 있으니 더 맛있습니다!")
    }
}

fn main() {
    let heap_pie = Box::new(Pie);
    heap_pie.eat();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
use core::fmt::Display;
use std::error::Error;

struct Pie;

#[derive(Debug)]
struct NotFreshError;

impl Display for NotFreshError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "이 파이는 신선하지 않군요!")
    }
}

impl Error for NotFreshError {}

impl Pie {
    fn eat(&self) -> Result<(), Box<dyn Error>> {
        Err(Box::new(NotFreshError))
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let heap_pie = Box::new(Pie);
    heap_pie.eat()?;
    Ok(())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
use std::rc::Rc;

struct Pie;

impl Pie {
    fn eat(&self) {
        println!("heap에 있으니 더 맛있습니다!")
    }
}

fn main() {
    let heap_pie = Rc::new(Pie);
    let heap_pie2 = heap_pie.clone();
    let heap_pie3 = heap_pie2.clone();

    heap_pie3.eat();
    heap_pie2.eat();
    heap_pie.eat();

    // 모든 참조 카운트 smart pointer가 여기서 drop 됩니다
    // heap 데이터인 Pie가 드디어 할당 해제됩니다
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
use std::cell::RefCell;

struct Pie {
    slices: u8,
}

impl Pie {
    fn eat(&mut self) {
        println!("heap에 있으니 더 맛있습니다!");
        self.slices -= 1;
    }
}

fn main() {
    // RefCell은 런타임에 메모리 안전성을 검증합니다
    // 주의: pie_cell은 mut가 아닙니다!
    let pie_cell = RefCell::new(Pie { slices: 8 });

    {
        // 그렇지만 mutable 참조를 대여할 수 있습니다!
        let mut mut_ref_pie = pie_cell.borrow_mut();
        mut_ref_pie.eat();
        mut_ref_pie.eat();

        // mut_ref_pie는 scope의 마지막에 drop 됩니다
    }

    // 이제 mutable 참조가 drop 되고 나면 immutable하게 대여할 수 있습니다
    let ref_pie = pie_cell.borrow();
    println!("{} 조각 남았습니다", ref_pie.slices);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
use std::sync::Mutex;

struct Pie;

impl Pie {
    fn eat(&self) {
        println!("지금은 오직 나만이 파이를 먹는다!");
    }
}

fn main() {
    let mutex_pie = Mutex::new(Pie);
    // 파이에 대한 잠겨있는 immutable한 참조를 빌려봅시다
    // lock은 실패할 수도 있기 때문에 그 결과는 unwrap 해야합니다
    let ref_pie = mutex_pie.lock().unwrap();
    ref_pie.eat();
    // 잠긴 참조는 여기서 drop 되며, mutex로 보호되는 값은 다른 이에 의해 쓰일 수 있습니다
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
use std::cell::RefCell;
use std::rc::Rc;

struct Pie {
    slices: u8,
}

impl Pie {
    fn eat_slice(&mut self, name: &str) {
        println!("{}가 한 조각 먹었습니다!", name);
        self.slices -= 1;
    }
}

struct SeaCreature {
    name: String,
    pie: Rc<RefCell<Pie>>,
}

impl SeaCreature {
    fn eat(&self) {
        // mutable 대여를 위해 파이에 대한 smart pointer를 사용
        let mut p = self.pie.borrow_mut();
        // 한 입 먹자!
        p.eat_slice(&self.name);
    }
}

fn main() {
    let pie = Rc::new(RefCell::new(Pie { slices: 8 }));
    // ferris와 sarah에겐 파이에 대한 smart pointer의 복제가 주어집니다
    let ferris = SeaCreature {
        name: String::from("ferris"),
        pie: pie.clone(),
    };
    let sarah = SeaCreature {
        name: String::from("sarah"),
        pie: pie.clone(),
    };
    ferris.eat();
    sarah.eat();

    let p = pie.borrow();
    println!("{} 조각 남았습니다", p.slices);
}