Rust Interview Questions

In Rust, the ownership system is governed by three core rules, which help ensure memory safety and prevent common programming errors like dangling pointers and data races. These rules are enforced at compile time. Here are the three rules of ownership in Rust:

1. Each Value Has a Single Owner

• Definition: Every value in Rust has a variable that is its owner.
• Implication: When the owner goes out of scope, the value is dropped (deallocated).
• Example:

  fn main() {
      let s1 = String::from("hello");
      let s2 = s1; // Ownership of the value is moved from s1 to s2.
      // s1 is no longer valid after this point.
      println!("{}", s2);
      // println!("{}", s1); // This would cause a compile-time error.
  }

2. There Can Only Be One Mutable Borrow at a Time, or Any Number of Immutable Borrows

• Definition: You can have either one mutable reference or multiple immutable references to a value, but not both simultaneously.
• Purpose: This rule prevents data races at compile time.
• Example of Immutable Borrowing:

  fn main() {
      let s = String::from("hello");
      let r1 = &s; // Immutable reference
      let r2 = &s; // Another immutable reference
      println!("{} and {}", r1, r2); // This is allowed.
  }

• Example of Mutable Borrowing:

  fn main() {
      let mut s = String::from("hello");
      let r1 = &mut s; // Mutable reference
      // let r2 = &mut s; // This would cause a compile-time error.
      // let r3 = &s; // This would also cause a compile-time error.
      println!("{}", r1);
  }

3. References Must Always Be Valid

• Definition: Rust ensures that references do not outlive the data they point to. This is managed through a system of lifetimes.
• Purpose: Prevents dangling references and ensures memory safety.
• Example:

  fn main() {
      let r;
      {
          let s = String::from("hello");
          r = &s;
          // s goes out of scope here, so r would be a dangling reference.
      }
      // println!("{}", r); // This would cause a compile-time error.
  }

Summary of the Rules:

1. Each value has a single owner: Ensures clear ownership and predictable deallocation of memory.
2. One mutable borrow or multiple immutable borrows: Prevents data races and ensures safe concurrent access.
3. References must always be valid: Ensures that references do not outlive their data, preventing dangling pointers.

By following these rules, Rust provides strong guarantees about memory safety, making it easier to write safe and efficient code without the need for a garbage collector.