Borrowing

Instead of transferring ownership when calling a function, you can let a function borrow the value:

  1. #[derive(Debug)]
  2. struct Point(i32, i32);
  4. fn add(p1: &Point, p2: &Point) -> Point {
  5.     Point(p1.0 + p2.0, p1.1 + p2.1)
  6. }
  8. fn main() {
  9.     let p1 = Point(3, 4);
  10.     let p2 = Point(10, 20);
  11.     let p3 = add(&p1, &p2);
  12.     println!("{p1:?} + {p2:?} = {p3:?}");
  13. }
  • The add function borrows two points and returns a new point.
  • The caller retains ownership of the inputs.

Notes on stack returns:

  • Demonstrate that the return from add is cheap because the compiler can eliminate the copy operation. Change the above code to print stack addresses and run it on the Playground. In the “DEBUG” optimization level, the addresses should change, while the stay the same when changing to the “RELEASE” setting:

    1. #[derive(Debug)]
    2. struct Point(i32, i32);
    4. fn add(p1: &Point, p2: &Point) -> Point {
    5.     let p = Point(p1.0 + p2.0, p1.1 + p2.1);
    6.     println!("&p.0: {:p}", &p.0);
    7.     p
    8. }
    10. fn main() {
    11.     let p1 = Point(3, 4);
    12.     let p2 = Point(10, 20);
    13.     let p3 = add(&p1, &p2);
    14.     println!("&p3.0: {:p}", &p3.0);
    15.     println!("{p1:?} + {p2:?} = {p3:?}");
    16. }

  • The Rust compiler can do return value optimization (RVO).

  • In C++, copy elision has to be defined in the language specification because constructors can have side effects. In Rust, this is not an issue at all. If RVO did not happen, Rust will always performs a simple and efficient memcpy copy.