Box<T> für Heap-Allokation und rekursive Typen

Snippet

Box<T> für Heap-Allokation und rekursive Typen

Box<T> alloziert Daten auf dem Heap statt auf dem Stack. Dies ist essentiell für rekursive Datenstrukturen wie Bäume und verkettete Listen, deren Größe zur Kompilierzeit nicht bekannt ist. Box<T> bietet Ownership-Semantik mit festen Zeigern.

snippet.rs
rust
enum TreeNode<T> {
    Leaf(T),
    Branch {
        value: T,
        left: Box<TreeNode<T>>,
        right: Box<TreeNode<T>>,
    },
}
 
impl<T: std::fmt::Debug> TreeNode<T> {
    fn new_leaf(value: T) -> Self {
        TreeNode::Leaf(value)
    }
    
    fn new_branch(value: T, left: TreeNode<T>, right: TreeNode<T>) -> Self {
        TreeNode::Branch {
            value,
            left: Box::new(left),
            right: Box::new(right),
        }
    }
    
    fn debug_print(&self, depth: usize) {
        match self {
            TreeNode::Leaf(v) => println!("{:width$}{:?}", "", v, width = depth * 2),
            TreeNode::Branch { value, left, right } => {
                println!("{:width$}{:?}", "", value, width = depth * 2);
                left.debug_print(depth + 1);
                right.debug_print(depth + 1);
            }
        }
    }
}

Erklärung

left: Box<TreeNode<T>>

Box verpackt rekursiven Typ, bricht unendliche Größe zur Kompilierzeit auf

Box::new(left)

Konvertiert stack-allokierten TreeNode zu heap-allokiertem Box

left.debug_print(depth + 1)

Box dereferenziert automatisch für Methodenaufrufe

fn new_branch(value: T, left: TreeNode<T>, right: TreeNode<T>)

Akzeptiert owned TreeNodes, konvertiert zu Boxes innerhalb des Enums

Vorheriges Snippet Nächstes Snippet

Verwandt

Aus deiner Bibliothek