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

This article introduces the knowledge of "how to use the type conversion of Ruth language". Many people will encounter this dilemma in the operation of actual cases, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

What is type conversion?

Type conversion is the process of converting our type B to type An according to the parameter signature type A required by the function, and the ownership of B cannot be changed. General function calls require us to pass references, and there is little need to pass ownership directly.

Many languages provide upward and downward transformations, such as Java and C++, so using (B) A can force B to A. However, a strong turn has certain risks. A failed strong turn in Java will throw a CastException, but in C++, sometimes no exceptions are thrown. You must use a higher version of cast series functions to convert to ensure that an exception is given when the conversion fails and avoid memory security problems.

Although Rust is a programming language with controllable security risks, there are some that developers need to know in advance, such as the unsatisfactory results of overturning between integers.

As operator

1. In the coding process, the most frequently used conversion is the cast of integers.

We often encounter such a type demand usize, this type generally refers to the length or array index, we only i32 and other integer variables can not be directly passed through, we must use the as keyword for cast, can pass the compiler detection.

However, some unexpected things can happen here, such as type truncation.

What is type truncation, that is, a variable A with a larger range of values is converted into a variable B with a smaller range of values, and if it is out of range, An is subtracted from the interval length of B.

For example, 128 is out of the range of type i8 (- 128127), and the value after strong conversion is equal to 128-256 copyright 128.

2, in learning Trait, we found a problem, type A can achieve a lot of Trait, some Trait function signature is the same, but the internal implementation is not the same, if you use An as the theme to call, the compiler can not determine which function should be called, so A must be forced up to a specific Trait to tell the compiler how to make a judgment.

For example, B and C are implemented by Trait,A with the same name as name (). When A wants to call B's name (), it needs to display the transformation to avoid ambiguity, such as:: name ().

3. As can also convert between parent and child types, such as & 'static str and &' a str.' The static life cycle is valid for the entire process life cycle, while the life cycle of'an is short, so we say & 'static is a subtype of &' a, represented by 'static:'a. As can freely convert parent-child types, such as &' static str as &'a str, which is meant to meet the life cycle requirements of some functions.

From and Into

These two Trait are defined in the convert module of the standard library, but they actually do the same thing. Don't be confused by From and Into.

To give a visual analogy, it is the same thing that I eat and eat by me. As long as I am eating, then the meal must be being eaten by me, is a reason.

Rust also defines a theorem for this: if type An implements From, then an instance of type B can be converted to type A by calling the into method.

For example, if our common string String type implements From (& str), then & str can be into () as String.

In most cases, we only need to implement the Trait of From, and Rust automatically implements the reverse Into for all those who implement From.

From and Into are not completely exception-free, and when we are not sure that the result of the transformation is what we want, we can implement the TryFrom and TryInto Trait to capture possible error messages.

AsRef and AsMut

AsRef and AsMut can convert types to immutable and mutable references, respectively. These two Trait are very helpful for us to implement extensible functions.

For example, if we want to design a function that allows both & String and & str to be passed in, do it like the test function in the following figure:

If we define a type ourselves, it is best to implement the Trait of AsRef, which will bring us a lot of unexpected benefits.

FromStr

Rust has a lot of built-in implementations to help us with type conversion. Conversions between strings and other types will implement the FromStr Trait by default.

If you want to convert a string to an integer, you can use the parse function, which automatically parses the string based on the return type to get the return value of the correct type.

Convert integers to strings, needless to say, just format macro formatting.

This is the end of the content of "how to use the Ruth language type conversion". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

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.