Box, stack and heap

All values in Rust are stack allocated by default. Values can be boxed
(allocated in the heap) by creating a Box<T>. A box is a smart pointer to a
heap allocated value of type T. When a box goes out of scope, its destructor
is called, the inner object is destroyed, and the memory in the heap is freed.

Boxed values can be dereferenced using the * operator; this removes one layer
of indirection. 

  1. use std::mem;
  3. #[allow(dead_code)]
  4. #[derive(Debug, Clone, Copy)]
  5. struct Point {
  6.     x: f64,
  7.     y: f64,
  8. }
  10. #[allow(dead_code)]
  11. struct Rectangle {
  12.     p1: Point,
  13.     p2: Point,
  14. }
  16. fn origin() -> Point {
  17.     Point { x: 0.0, y: 0.0 }
  18. }
  20. fn boxed_origin() -> Box<Point> {
  21.     // Allocate this point in the heap, and return a pointer to it
  22.     Box::new(Point { x: 0.0, y: 0.0 })
  23. }
  25. fn main() {
  26.     // (all the type annotations are superfluous)
  27.     // Stack allocated variables
  28.     let point: Point = origin();
  29.     let rectangle: Rectangle = Rectangle {
  30.         p1: origin(),
  31.         p2: Point { x: 3.0, y: 4.0 }
  32.     };
  34.     // Heap allocated rectangle
  35.     let boxed_rectangle: Box<Rectangle> = Box::new(Rectangle {
  36.         p1: origin(),
  37.         p2: origin()
  38.     });
  40.     // The output of functions can be boxed
  41.     let boxed_point: Box<Point> = Box::new(origin());
  43.     // Double indirection
  44.     let box_in_a_box: Box<Box<Point>> = Box::new(boxed_origin());
  46.     println!("Point occupies {} bytes in the stack",
  47.              mem::size_of_val(&point));
  48.     println!("Rectangle occupies {} bytes in the stack",
  49.              mem::size_of_val(&rectangle));
  51.     // box size = pointer size
  52.     println!("Boxed point occupies {} bytes in the stack",
  53.              mem::size_of_val(&boxed_point));
  54.     println!("Boxed rectangle occupies {} bytes in the stack",
  55.              mem::size_of_val(&boxed_rectangle));
  56.     println!("Boxed box occupies {} bytes in the stack",
  57.              mem::size_of_val(&box_in_a_box));
  59.     // Copy the data contained in `boxed_point` into `unboxed_point`
  60.     let unboxed_point: Point = *boxed_point;
  61.     println!("Unboxed point occupies {} bytes in the stack",
  62.              mem::size_of_val(&unboxed_point));
  63. }