Lebensdauern

Compilerfehler Lebensdauer

Programm 1:

/// Adds a Display-able object into a vector of
/// Display trait objects
use std::fmt::Display;
fn add_displayable<T: Display>(
    v: &mut Vec<Box<dyn Display>>,
    t: T
) {
    v.push(Box::new(t));
}

Wenn Sie versuchen würden, dieses Programm zu kompilieren, welche der folgenden Beschreibungen trifft am besten auf den Compilerfehler zu, den Sie erhalten würden?

1. der Typ T überlebt die Lebensdauer der Referenz &mut Vec<..> nicht

2. der Typ T könnte dynamisch groß sein und kann nicht in ein Trait-Objekt umgewandelt werden

3. der Typ T lebt nicht lange genug, wenn er in ein Trait-Objekt umgewandelt wird

4. der Typ T kann nicht in eine Box gelegt werden, wenn er eine Referenz enthält

Prüfen

Beim Umwandeln von Box<T> in Box<dyn Display> (implizit in v.push(..)) verlangt Rust, dass das Trait-Objekt dyn Display den Vektor überlebt. Die Lebensdauer von T ist jedoch nicht spezifiziert, sodass T möglicherweise nicht lange genug lebt.

---

Undefined Behavior Lebensdauern

Programm 1:

/// Adds a Display-able object into a vector of
/// Display trait objects
use std::fmt::Display;
fn add_displayable<T: Display>(
    v: &mut Vec<Box<dyn Display>>,
    t: T
) {
    v.push(Box::new(t));
}

Normalerweise gibt der Compiler den folgenden Fehler zurück, wenn Sie versuchen, diese Funktion zu kompilieren:

error[E0310]: the parameter type `T` may not live long enough
 --> test.rs:6:12
  |
6 |     v.push(Box::new(t));
  |            ^^^^^^^^^^^

Nehmen Sie an, dass der Compiler diese Funktion NICHT abgelehnt hat. Welche (falls zutreffend) der folgenden Programme würden (1) den Compiler passieren und (2) bei Ausführung möglicherweise undefiniertes Verhalten verursachen? Markieren Sie jedes Programm, das beide Kriterien erfüllt, ODER markieren Sie „Keines dieser Programme“, wenn keines davon zutrifft.

1. let mut v: Vec<Box<dyn Display>> = Vec::new();
   {
   let s = String::from("Hello world");
   add_displayable(&mut v, s);
   }
   println!("{}", v[0]);

2. let mut v: Vec<Box<dyn Display>> = Vec::new();
   {
   let n = 0;
   add_displayable(&mut v, &n);
   }
   println!("{}", v[0]);

3. Keines dieser Programme

4. let mut v: Vec<Box<dyn Display>> = Vec::new();
   add_displayable(&mut v, 5);

Prüfen

Dieses Programm ist speicherunsicher. Um eine Verletzung der Speichersicherheit zu erzeugen, muss das Programm einen Typ T erstellen, der Referenzen enthält, die den Vektor nicht überleben. Wenn Sie beispielsweise &n hinzufügen, wobei n den Gültigkeitsbereich vor v verlässt, bedeutet dies, dass die spätere Verwendung von v[0] ein Lesen von freigegebenem Speicher ist.

---

Lebensdauer-Annotationen korrigieren

Programm 1:

/// Adds a Display-able object into a vector of
/// Display trait objects
use std::fmt::Display;
fn add_displayable<T: Display>(
    v: &mut Vec<Box<dyn Display>>,
    t: T
) {
    v.push(Box::new(t));
}

Welche der folgenden Korrekturen (gelb hervorgehoben) erfüllt diese drei Kriterien am besten:

1. Die korrigierte Funktion wird vom Rust-Compiler akzeptiert,
2. Die korrigierte Funktion bewahrt die Absicht des ursprünglichen Codes, und
3. Die korrigierte Funktion führt keine unnötigen Ineffizienzen ein

1. fn add_displayable<T: Display + 'static>(
   v: &mut Vec<Box<dyn Display>>,
   t: T
   ) {
   v.push(Box::new(t));
   }

2. fn add_displayable<'a, T: Display + 'a>(
   v: &'a mut Vec<Box<dyn Display>>,
   t: T
   ) {
   v.push(Box::new(t));
   }

3. fn add_displayable<'a, T: Display + 'a>(
   v: &mut Vec<Box<dyn Display + 'a>>,
   t: T
   ) {
   v.push(Box::new(t));
   }

4. fn add_displayable<T: Display + Clone>(
   v: &mut Vec<Box<dyn Display>>,
   t: T
   ) {
   v.push(Box::new(t.clone()));
   }

Prüfen

Die idiomatischste Korrektur besteht darin, zu spezifizieren, wie die Lebensdauer von T mit der Lebensdauer des Trait-Objekts dyn Display zusammenhängen sollte. Hier bedeutet das, einen Lebensdauerparameter 'a hinzuzufügen, der besagt, dass T 'a überlebt und dass die Trait-Objekte ebenfalls mindestens für 'a leben. Die Verwendung einer 'static-Schranke ist dasselbe, aber schlechter: Sie ist einfach weniger ausdrucksstark und verbietet den Trait-Objekten des Vektors, jemals Referenzen zu halten. Das Anbringen der Lebensdauer 'a an die Referenz &'a mut Vec<..> ist nicht korrekt und behebt den Compilerfehler nicht.

---