error [E0716]: temporary value dropped while borrowed (rust)

by

Your problem is indeed at the line indicated by the compile. Let’s analyze it a little bit:

fn fun1(s1: &String, v1: &mut Vec1) {
    v1.insert(0, &s1.clone());
}

Your understanding is not quite correct. Let’s look at the insert’s signature:

pub fn insert(&mut self, index: usize, element: T)

The type T means that it captures by value, so element won’t be used after the call. You just tweaked this by making the vector a Vec<&String> not a Vec<String>.

Outcome: You want to insert a reference to a clone of the string

How it is done: you clone and insert the the reference

The difference between rust’s reference and C/C++ pointers is that rust doesn’t allow reference to point to deallocated data (they must always point to valid data). When you clone the string, you create a carbon copy of it, but that carbon copy is available only for the lifetime of fun1. When the call to fun1 ends, the cloned string will be dropped, because the function owned that clone, so it is responsible for cleaning it (rust’s ownership based resource management).

In C++ that would have been valid: you could’ve allocated a pointer and push that pointer into the vector, but rust does not allow such things.

Your fun1 is equivalent to this one:

fn fun1(s1: &String, v1: &mut Vec1) {
    let im_tmp = s1.clone();
    v1.insert(0, &im_tmp);
}

Similar operation should always ring a bell becase im_tmp will be cleaned. To fix your issue:

type Vec1<'a> = Vec::<String>;

fn fun1(s1: &String, v1: &mut Vec1) {
    v1.insert(0, s1.clone());
}

fn main() {
    let mut vec1 = Vec::new();
    let str1 = String::new();
    fun1(&str1, &mut vec1);
    println!("{:?}", vec1);
}

The type is no longer a vector of references, but instead the actual object. In fun1, the vector takes ownership of the cloned string.

Another example where your vector has the type you created, is this one, but this works because the compiler can infer the lifetime of the cloned string. Notice, if you do vec1.insert(0, &str1.clone()) won’t work , because tha reference to the clone will be available only for the lifetime of the call to the insert:

type Vec1<'a> = Vec::<&'a String>;

fn main() {
    let mut vec1 = Vec::new();
    let str1 = String::new();
    let clone = str1.clone();
    vec1.insert(0, &clone);
    println!("{:?}", vec1);
}

More Related Contents:

  1. What are non-lexical lifetimes?
  2. How can I include a module from another file from the same project?
  3. What does “Sized is not implemented” mean?
  4. Deriving a trait results in unexpected compiler error, but the manual implementation works
  5. How do I implement Copy and Clone for a type that contains a String (or any type that doesn’t implement Copy)?
  6. Mutably borrow one struct field while borrowing another in a closure
  7. How do I convert a Vector of bytes (u8) to a string?
  8. When is it useful to define multiple lifetimes in a struct?
  9. Can I write an Iterator that mutates itself and then yields a reference into itself?
  10. How to update-or-insert on a Vec?
  11. Lifetime troubles sharing references between threads
  12. What is the syntax: `instance.method::()`?
  13. Why does passing a closure to function which accepts a function pointer not work?
  14. “expected type parameter, found struct”
  15. Adding an append method to a singly linked list
  16. How do you set, clear and toggle a single bit in Rust?
  17. Lifetime of variables passed to a new thread
  18. How can I co-sort two Vecs based on the values in one of the Vecs?
  19. How can I distinguish between a deserialized field that is missing and one that is null?
  20. Cannot create a generic function that uses a literal zero
  21. Is there a way to combine multiple traits in order to define a new trait? [duplicate]
  22. How to avoid temporary allocations when using a complex key for a HashMap?
  23. Why does compilation not fail when a member of a moved value is assigned to?
  24. Why does a mutable borrow of a closure through DerefMut not work?
  25. What does “missing lifetime specifier” mean when storing a &str in a structure?
  26. Why can Serde not derive Deserialize for a struct containing only a &Path?
  27. How to quiet a warning for a single statement in Rust?
  28. Use of undeclared type or module `std` when used in a separate module
  29. Is there an elegant solution to modifying a structure while iterating?
  30. How do I cope with lazy iterators?

Leave a Comment