Methoden und Borrowing

Referenz-Reborrowing bei Methodenaufruf

Angenommen, Sie haben eine Variable v vom Typ &mut Vec<i32> und möchten die Methode len mit der folgenden Signatur aufrufen:

impl Vec<i32> {
  fn len(&self) -> usize {
    /* ... */
  }
}

Wenn Sie versuchen, den Ausdruck v.len() zu kompilieren, welche der folgenden Aussagen beschreibt am besten, was passiert?

1. Es kompiliert, weil &self jede Art von Referenz akzeptieren kann

2. Es kompiliert, weil die &mut -Referenz implizit als & -Referenz neu geborgt wird

3. Es kompiliert nicht, weil &mut Vec<i32> nicht derselbe Typ ist wie &Vec<i32>

4. Es kompiliert nicht, v wird nicht explizit dereferenziert

Prüfen

Der Ausdruck v.len() wird zu Vec::len(&*v) desugart, was ein gültiges Re-Borrowing von v ist, daher kompiliert dieser Ausdruck. Sie können v jedoch nicht direkt an Vec::len übergeben, da &self sich spezifisch auf unveränderliche Referenzen bezieht.

---

Idiomatische Methoden-Signaturen

Betrachten Sie diese beiden Methoden, die ein Feld einer Struktur inkrementieren. Welcher Stil wäre für Rust idiomatischer?

struct Point(i32, i32);
impl Point {
  fn incr_v1(mut self)  { self.0 += 1; }
  fn incr_v2(&mut self) { self.0 += 1; }
}

1. incr_v1

2. Keine ist idiomatisch

3. Beide sind idiomatisch

4. incr_v2

Prüfen

Die Methode incr_v1 ist nicht idiomatisch, da sie die Ownership des Point konsumiert. Das bedeutet, dass nach dem Aufruf von p.incr_v1() , p unbrauchbar wäre, was für diese Methode wahrscheinlich nicht beabsichtigt ist.

---

Strukturfeld inkrementieren

struct Point(i32, i32);
impl Point {
  fn incr_x(&mut self) {
    self.0 += 1;
  }
}

fn main() {
  let mut p = Point(0, 0);
  p.incr_x();
  println!("{}", p.0);
}

1. Kompiliert
2. Kompiliert nicht

Prüfen

Denken Sie daran, dass .0 für Tuple-Strukturen wie Point gültig ist.

---

Gleichzeitiges Borrowing

struct Point {
  x: i32,
  y: i32
}

impl Point {
  fn get_x(&mut self) -> &mut i32 {
    &mut self.x
  }
}

fn main() {
  let mut p = Point { x: 1, y: 2 };
  let x = p.get_x();
  *x += 1;
  println!("{} {}", *x, p.y);
}

1. Kompiliert
2. Kompiliert nicht

Prüfen

Da get_x das gesamte p mutabel borgt, kann ein Programm p in keiner Weise verwenden, bis x nicht mehr benutzt wird. Daher ist das Lesen von x und p.y in derselben Zeile ein Ownership-Fehler.

---