code for 0x10 Smart Pointers

mike-kfed · mike-kfed · commit e8c937de8aef · 2021-07-02T17:37:26.000+02:00
diff --git a/10_smart_pointers/python/bintree.py b/10_smart_pointers/python/bintree.py
@@ -0,0 +1,37 @@
+class Node:
+    printed = set()
+
+    def __init__(self, value):
+        self.parent = None
+        self.left = None
+        self.right = None
+        self.value = value
+
+    def __repr__(self):
+        try:
+            if id(self) in self.printed:
+                return f"-"
+            self.printed.add(id(self))
+            spaces = " " * len(self.printed)
+            s = f"Node\n{spaces}{spaces}parent: {self.parent}, left: {self.left}, right: {self.right}, v: {self.value}\n"
+            return s
+        except RecursionError:
+            return "-"
+
+
+if __name__ == '__main__':
+    root = Node(0)
+    node = Node(1)
+    node.parent = root
+    root.left = node
+    node2 = Node(2)
+    root.parent = node2
+
+    print("Root:", root)
+    Node.printed = set()
+    print("Parent left:", root.left.parent.value)
+    Node.printed = set()
+    print("ids: {} {}".format(id(node2), id(root.parent)))
+    del node2
+    #root.parent = None
+    print("Parent:   ", root.parent)
diff --git a/10_smart_pointers/python/rc.py b/10_smart_pointers/python/rc.py
@@ -0,0 +1,23 @@
+import sys
+
+if __name__ == "__main__":
+    rc_examples = "Rc examples"
+    print("refcount of rc_examples", sys.getrefcount(rc_examples))
+
+    def scope():
+        print("rc created")
+
+        rc_a = rc_examples
+        print("refcount of rc_a", sys.getrefcount(rc_a))
+
+        def subscope():
+            rc_b = rc_a
+            print("refcount of rc_b", sys.getrefcount(rc_b))
+            print("refcount of rc_a", sys.getrefcount(rc_a))
+            print("refcount of rc_examples", sys.getrefcount(rc_examples))
+
+        subscope()
+        print("refcount of rc_examples after del rc_b", sys.getrefcount(rc_examples))
+
+    scope()
+    print("refcount of rc_examples after del rc_a", sys.getrefcount(rc_examples))
diff --git a/10_smart_pointers/rust/bintree.rs b/10_smart_pointers/rust/bintree.rs
@@ -0,0 +1,54 @@
+/// for illustration purposes only, do not use IRL!
+use std::cell::RefCell; // a "runtime borrow-checker"
+use std::fmt::Debug;
+use std::rc::{Rc, Weak};
+
+#[derive(Debug)]
+struct Node<T> {
+    parent: Option<Weak<RefCell<Node<T>>>>,
+    left: Option<Rc<RefCell<Node<T>>>>,
+    right: Option<Rc<RefCell<Node<T>>>>,
+    value: T,
+}
+
+impl<T: Debug> Node<T> {
+    fn new(value: T) -> Node<T> {
+        Node {
+            parent: None,
+            left: None,
+            right: None,
+            value,
+        }
+    }
+
+    fn print_parent(&self) {
+        if let Some(parent) = &self.parent {
+            if let Some(parent) = parent.upgrade() {
+                println!("Parent: {:?}", parent.borrow().value);
+            } else {
+                println!("Parent: no more parent");
+            }
+        } else {
+            println!("Parent: None");
+        }
+    }
+}
+
+fn main() {
+    let root = Rc::new(RefCell::new(Node::new(0)));
+    let node = Rc::new(RefCell::new(Node::new(1)));
+    node.borrow_mut().parent = Some(Rc::downgrade(&root));
+
+    let node2 = Rc::new(RefCell::new(Node::new(2)));
+
+    root.borrow_mut().parent = Some(Rc::downgrade(&node2));
+    root.borrow_mut().left = Some(node);
+
+    println!("Root:   {:?}", *root.borrow());
+    if let Some(left) = &root.borrow().left {
+        &left.borrow().print_parent();
+    };
+    &root.borrow().print_parent();
+    drop(node2);
+    &root.borrow().print_parent();
+}
diff --git a/10_smart_pointers/rust/rc.rs b/10_smart_pointers/rust/rc.rs
@@ -0,0 +1,30 @@
+use std::rc::Rc;
+
+fn main() {
+    let rc_examples = "Rc examples".to_string();
+    // new scope
+    {
+        println!("--- rc_a is created ---");
+
+        let rc_a: Rc<String> = Rc::new(rc_examples);
+        println!("Reference Count of rc_a: {}", Rc::strong_count(&rc_a));
+
+        // one more scope
+        {
+            let rc_b: Rc<String> = Rc::clone(&rc_a);
+            println!("Ref Count of rc_b: {}", Rc::strong_count(&rc_b));
+            println!("Ref Count of rc_a: {}", Rc::strong_count(&rc_a));
+
+            // Two `Rc`s are equal if their inner values are equal
+            println!("rc_a and rc_b are equal: {}", rc_a.eq(&rc_b));
+
+            // We can use methods of a value directly
+            println!("Length of the value inside rc_a: {}", rc_a.len());
+            println!("Value of rc_b: {}", rc_b);
+        }
+
+        println!("Reference Count of rc_a: {}", Rc::strong_count(&rc_a));
+
+        println!("--- rc_a is dropped out of scope ---");
+    }
+}
diff --git a/10_smart_pointers/rust/smartpointers.rs b/10_smart_pointers/rust/smartpointers.rs
@@ -0,0 +1,32 @@
+use std::error;
+use std::rc::Rc;
+
+type Result<T> = std::result::Result<T, Box<dyn error::Error>>;
+
+struct List {
+    next: Option<Box<List>>,
+    value: i32,
+}
+
+fn main() -> Result<()> {
+    let a = Box::new(5);
+    println!("deref of box {:?} yields {}", a, *a);
+    let mut l = List {
+        next: None,
+        value: 1,
+    };
+    l.next = Some(Box::new(List {
+        next: None,
+        value: 2,
+    }));
+    println!("list value {}", l.value);
+
+    let b = Rc::new(*a);
+    let _c = Rc::clone(&b); // increase reference count (cheap)
+    println!("{} refcount: {}", &b, Rc::strong_count(&b));
+    // if b is not a Rc type this is potentially deep-copying (expensive)
+    // avoid this notation when doing refcount clones
+    let _d = b.clone();
+    println!("{} refcount: {}", &b, Rc::strong_count(&b));
+    Ok(())
+}
