Ownership of struct data is a Rust feature that ensures that the data stored in a struct is valid for as long as the struct is. This is done by tracking the ownership of each piece of data, and ensuring that no piece of data is ever accessed after it has been dropped. For example, the following struct definition uses the owned String type rather than the &str string slice type:
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
This means that each instance of the User struct owns its own copy of the username and email strings. This ensures that the strings will not be dropped until the struct itself is dropped. It is also possible for structs to store references to data owned by something else. However, to do so requires the use of lifetimes, a Rust feature. Lifetimes ensure that the data referenced by a struct is valid for as long as the struct is. For example, the following struct definition stores references to two &str string slices:
struct User<'a> {
active: bool,
username: &'a str,
email: &'a str,
sign_in_count: u64,
}
The lifetime specifier `'a` tells the compiler that the references to the username and email strings must be valid for the lifetime of the User struct. This is enforced by the compiler, which will ensure that the references are not used after the struct is dropped. Here is a new example of ownership of struct data:
struct Person {
name: String,
age: u8,
}
struct Family {
parents: Vec<Person>,
children: Vec<Person>,
}
fn main() {
let mut family = Family {
parents: Vec::new(),
children: Vec::new(),
};
let parent1 = Person {
name: "John Doe".to_string(),
age: 40,
};
let parent2 = Person {
name: "Jane Doe".to_string(),
age: 35,
};
family.parents.push(parent1);
family.parents.push(parent2);
let child1 = Person {
name: "John Doe Jr.".to_string(),
age: 10,
};
family.children.push(child1);
// The parents and children of the family struct now own their own copies of the name and age data.
}
In this example, the Person struct owns its own copies of the name and age data. The Family struct also owns its own copies of the name and age data for each of its parents and children. This ensures that the data is valid for as long as the structs themselves are valid.
