- Small knowledge, big challenge! This article is participating in the creation activity of “Essential Tips for Programmers”.
Basic grammar
Continue to trait
- We can also use
trait
Add member methods to other types- The following code,
i32
We didn’t write it at all - But we can give
i32
Increase method
- The following code,
trait Double {
fn double(&self) - >Self;
}
impl Double for i32 {
fn double(&self) - >i32{*self * 2}}fn main() {
let x : i32 = 10.double();
// Outputs the value of type double as 20
println!("Values of type double are {}",x)
}
Copy the code
Generic function call syntax
trait Cook {
fn start(&self);
}
trait Wash {
fn start(&self);
}
struct Chef;
impl Cook for Chef {
fn start(&self) {
println!("Start cooking!!"); }}impl Wash for Chef {
fn start(&self) {
println!("Wash the dishes!!"); }}fn main() {
let me = Chef;
/ / output
// Start cooking!
// Start washing dishes!!
<Cook>::start(&me);
<Chef as Wash>::start(&me);
}
Copy the code
- The above code is in
main
In, write two specificallytrait
To call- Because if you just write one sentence
me.start()
Ambiguity arises - So you have to be careful when you call it, you have to be careful which one it is
trait
- Because if you just write one sentence
The generic
fn test<T : Debug>(x : T) {
println!("this is {:? }.",x);
}
fn main() {
/* this is "Test". this is 77. this is true. this is ['n', 'a', 's', 's']. */
test("Test");
test(77i32);
test(true);
test(['n'.'a'.'s'.'s']);
}
Copy the code
- Above code, in which
{:? }
Is the formatting control character
An array of
fn main() {
let a: [i32; 3] = [1.2.3];
let b: [i32; 10] = [0; 10];
/ / 1 2 3
for i in a {
print!("{}",i);
}
// 0 0 0 0 0 0 0 0 0
for i in b {
print!("{}",i); }}Copy the code
- Above code: pay attention to array length, array type
- An array of
b
It’s ten0
- An array of
Array slice
- We can think of an array slice as a pointer to an array
- You can view it as one of the arrays
view
- The array in this example is
[T; n]
The type of - The pointer type is
&[T; n]
To convert an array type to a slice type by internal compilation&[T]
- You can view it as one of the arrays
fn main() {
fn mut_arr(a : &mut [i32]) {
a[2] = 5;
}
println!("size of &[i32; 3] : {:? }", std::mem::size_of::<&[i32; 3> ());println!("size of &[i32] : {:?}", std::mem::size_of::<&[i32> ());let mut v : [i32; 3] = [1.2.3];
{
let s : &mut [i32; 3] = &mut v;
mut_arr(s);
}
// The output is:
// size of &[i32; 3] : 8
// size of &[i32] : 16
/ / [1, 2, 5]
println!("{:? }",v);
}
Copy the code
- The above code contains variables
v
is[i32; 3]
type- variable
s
is&mut [i32; 3]
Type, which takes up the same amount of space as the pointer - When automatically converted
&mut [i32; 3]
Type, passing in a functionmut_arr
- Based on the output, you can see that the space occupied is equal to the space occupied by two Pointers
- Inside the function, the value of v for the external array is changed
- variable
Fat pointer andDST
- Array slicing contains not only Pointers to arrays, but also lengths of information
Fat pointer
-
Fat paper corresponds to dynamic size type, or DST for short
-
For example, we use an indeterminate array of type [T] and the corresponding fat pointer of type &[T].
-
It is impossible to determine the size of the space occupied by the type
-
So you can’t declare an instance of a variable on the stack that doesn’t grow
-
fn example_slice(arr: &[i32]) {
unsafe {
let (v1, v2) : (usize.usize) = std::mem::transmute(arr);
println!("Value1 is {:x}",v1);
println!("Value2 is {:x}",v2); }}fn main() {
let arr : [i32; 5] = [1.2.3.4.5];
let addr : &[i32; 5] = &arr;
println!("Address of arr is: {:p}",addr);
// The output is:
// Address of arr is: 0x7ffee759f424
// Value1 is 7ffee759f424
// Value2 is 5
example_slice(addr as& [i32]);
}
Copy the code
- In the code above,
arr
Is the length of the5
- Among them
addr
Is pointing toarr
A pointer to - Use the function to convert our array directly to a length and an address pointing to the source array
- Among them
Range
Range
Represents an interval- use
.
Represents the left open and right closed interval - Such as
1.. 7
It stands for 1 to 7
- use
fn main() {
let a = 1.7;
// 1 2 3 4 5 6
for i in a {
print!("{:? }\t",i); }}Copy the code