Shulou(Shulou.com)06/01 Report--

This article mainly introduces "what is the life cycle of Rust". In daily operation, I believe many people have doubts about the life cycle of Rust. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful to answer the doubts of "what is the life cycle of Rust?" Next, please follow the editor to study!

Rust lifecycle mechanism is a resource management mechanism as important as ownership mechanism. The reason why this concept is introduced is to deal with the problem of resource management in complex type systems. Reference is an indispensable mechanism when dealing with complex types, after all, complex type data cannot be easily copied and calculated by the processor. But references often lead to extremely complex resource management problems, so first take a look at overhanging references:

Example

{let r; {let x = 5; r = & x;} println! ("r: {}", r);}

This code will not pass the Rust compiler because the value referenced by r has been released before it is used.

Learning Rust Lifecycle Learning Rust Lifecycle

The green range'an in the above figure represents the life cycle of r, and the blue range'b represents the life cycle of x. Obviously,'b is much smaller than'a, and the reference must be valid within the lifetime of the value.

We have always used String in structures instead of & str, and we use a case to explain why:

Example

Fn longer (S1: & str, S2: & str)-> & str {if s2.len () > s1.len () {S2} else {S1}

The longer function takes the longer of the two string slices S1 and S2 and returns its reference value. But only this code will not be compiled because the return value reference may return an expired reference:

Example

Fn main () {let r; {let S1 = "rust"; let S2 = "ecmascript"; r = longer (S1, S2);} println! ("{} is longer", r);}

Although this program has been compared, the source values S1 and S2 are invalid when r is used. Of course, we can move the use of r to the life cycle of S1 and S2 to prevent the occurrence of such errors, but for the function, it does not know what is going on outside of itself. In order to ensure that the value it passes out is normal, the principle of mandatory ownership eliminates all dangers, so the longer function cannot be compiled.

Lifecycle comment

Lifecycle annotations are a way to describe reference lifecycles. Although this does not change the lifecycle of the reference, you can declare that the lifecycle of the two references is the same in the appropriate place. The note begins with a single quotation mark, followed by a lowercase word:

& i32 / / regular references & references with lifecycle annotations &'a mut i32 / / references with lifecycle annotations in variants

Let's transform the longer function with lifecycle annotations:

Example

Fn longer'a > (S1: &'a str, S2: &'a str)-> &'a str {if s2.len () > s1.len () {S2} else {S1}}

We need to standardize the name of the life cycle with a generic declaration, and then the life cycle of the return value of the function will be the same as the life cycle of the two parameters, so you can write this when calling:

Example

Fn main () {let r; {let S1 = "rust"; let S2 = "ecmascript"; r = longer (S1, S2); println! ("{} is longer", r);}}

The running result of the combination of the above two programs:

Ecmascript is longer

Note: don't forget the principle of automatic type determination.

Using string slice references in structures

This is the question left before, and here is the answer:

Example

Fn main () {struct Str'a > {content: &'a str} let s = Str {content: "string_slice"}; println! ("s.content = {}", s.content);}

Running result:

S.content = string_slice

If there is a method definition for the structure Str:

Example

Impl'a > Stra > {fn get_content (& self)-> & str {self.content}}

The return value here has no lifecycle comments, but it doesn't hurt to add it. This is a historical issue. Early Rust did not support automatic lifecycle judgment, and all lifecycles must be strictly declared, but mainstream stable versions of Rust already support this feature.

Static life cycle

Lifecycle annotations have a special feature: 'static. The exact data type represented by all string constants enclosed in double quotes is & 'static str,' static, which represents the life cycle from the beginning of the program to the end of the program.

Generics, features, and lifecycle work together

Example

Use std::fmt::Display;fn longest_with_an_announcement'a, T > (x: &'a str, y: &'a str, ann: t)-> &'a str where T: Display {println! ("Announcement! {}", ann); if x.len () > y.len () {x} else {y}}

At this point, the study of "what is the life cycle of Rust" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.