2.2 Rust 数据类型

 2.2 数据类型

1
2
1let guess: u32 = "42".parse().expect("Not a number!");

2

Rust has four primary scalar types: integers, floating-point numbers, Booleans, and characters. 

 整数类型

1
2
3
4
1 u32,this type declaration indicates that the value it’s associated with should be an unsigned integer (signed integer types start with i, instead of u) that takes up 32 bits of space. 

2

3Additionally, the isize and usize types depend on the kind of computer your program is running on: 64 bits if you’re on a 64-bit architecture and 32 bits if you’re on a 32-bit architecture.

4

Note that all number literals except the byte literal allow a type suffix, such as 57u8, and _ as a visual separator, such as 1_000.

整数溢出

1
2
3
4
1Let’s say that you have a u8, which can hold values between zero and 255. What happens if you try to change it to 256? This is called “integer overflow,” and Rust has some interesting rules around this behavior. When compiling in debug mode, Rust checks for this kind of issue and will cause your program to panic, which is the term Rust uses when a program exits with an error. 

2

3In release builds, Rust does not check for overflow, and instead will do something called “two’s complement wrapping.” In short, 256 becomes 0, 257 becomes 1, etc. Relying on overflow is considered an error, even if this behavior happens. If you want this behavior explicitly, the standard library has a type, Wrapping, that provides it explicitly.

4

浮点类型

Rust’s floating-point types are
 f32
 and
 f64, which are 32 bits and 64 bits in size, respectively. The default type is
 f64
 because on modern CPUs it’s roughly the same speed as
 f32
 but is capable of more precision.

1
2
3
4
5
6
1fn main() {

2    let x = 64.0 ; //f64

3    let y: f32 = 32.0; //f32

4    println!("64:{},32:{}",x,y);

5}

6

1
2
1The f32 type is a single-precision float, and f64 has double precision.

2

数字运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1fn main() {

2    // addition

3    let _sum = 5 + 10;

4

5    // subtraction

6    let _difference = 95.5 - 4.3;

7

8    // multiplication

9    let _product = 4 * 30;

10

11    // division

12    let _quotient = 56.7 / 32.2; //1.7608695652173911 小数点后16位

13    let _ff32 = 7f32 / 3f32;   //2.3333333  7位小数

14

15    // remainder

16    let _remainder = 13 % 5;  //3

17    println!{"32位除法:{}",_ff32}

18    println!{"默认64位除法：{}",_quotient};

19    println!{"求余：{}",_remainder};

20}

21

 整数与浮点数不可以混合运算，比如 let _cc = 10 * 3.0; 会报以下错误

^ no implementation for

{integer} * {float}

error: Could not compile

datatype

.

布尔类型

1
2
3
4
5
1fn main() {

2    let _t = true;

3    let _f: bool = false; // with explicit type annotation

4}

5

 字符类型

1
2
3
4
5
6
1fn main() {

2    let _a = 'z';

3    let _b = 'ℤ';

4    let _c = 'Z';

5}

6

1
2
1 Rust’s char type represents a Unicode Scalar Value, which means it can represent a lot more than just ASCII. Accented letters; Chinese, Japanese, and Korean characters; emoji; and zero-width spaces are all valid char values in Rust. Unicode Scalar Values range from U+0000 to U+D7FF and U+E000 to U+10FFFF inclusive. However, a “character” isn’t really a concept in Unicode, so your human intuition for what a “character” is may not match up with what a char is in Rust.

2

复合类型

Compound types
 can group multiple values into one type. Rust has two primitive compound types: tuples and arrays.

元组

A tuple is a general way of grouping together some number of other values with a variety of types into one compound type. Tuples have a fixed length: once declared, they cannot grow or shrink in size.

Each position in the tuple has a type, and the types of the different values in the tuple don’t have to be the same.
 

1
2
3
4
5
6
7
1fn main() {

2    let _tup: (i32, f64, u8) = (500, 6.4, 1);

3    let _aa = (1,2.3,"wa ka ka ");

4    let (_x,_y,_z) = _aa;

5    println!("The value of z is:{}",_z)

6}

7

1
2
3
4
1This program first creates a tuple and binds it to the variable tup. It then uses a pattern with let to take tup and turn it into three separate variables, x, y, and z. This is called destructuring, because it breaks the single tuple into three parts. 

2

3 In addition to destructuring through pattern matching, we can access a tuple element directly by using a period (.) followed by the index of the value we want to access. 

4

1
2
3
4
5
6
7
8
1fn main() {

2    let _x: (i32, f64, u8) = (500, 6.4, 1);

3    let _five_hundred = _x.0;

4    let _six_point_four =_x.1;

5    let _one = _x.2;

6    println!("第三个元素:{}",_one);

7}

8

数组类型 

Unlike a tuple, every element of an array must have the same type. Arrays in Rust are different from arrays in some other languages because arrays in Rust have a fixed length, like tuples.

1
2
3
4
1fn main() {

2    let _a = [1, 2, 3, 4, 5];

3}

4

Arrays are useful when you want your data allocated on the stack rather than the heap or when you want to ensure you always have a fixed number of elements. An array isn’t as flexible as the vector type, though. A vector is a similar collection type provided by the standard library that is allowed to grow or shrink in size. If you’re unsure whether to use an array or a vector, you should probably use a vector. 

 It’s very unlikely that such a program will need to add or remove months, so you can use an array because you know it will always contain 12 items

1
2
3
4
5
6
1fn main() {

2    let _a = [1, 2, 3, 4, 5];

3    let _months = ["January", "February", "March", "April", "May", "June", "July",

4              "August", "September", "October", "November", "December"];

5}

6

Arrays have an interesting type; it looks like this: [type; number]. For example:

1
2
3
4
1fn main() {

2    let _b: [i32; 5] = [1, 2, 3, 4, 5];

3}

4

访问数组元素

1
2
3
4
5
6
1fn main() {

2    let _b: [i32; 5] = [1, 2, 3, 4, 5];

3    let _c1 = _b[0];

4    let _c2 = _b[1];

5}

6

数组越界

1
2
3
4
5
6
7
8
9
1fn main() {

2    let a = [1, 2, 3, 4, 5];

3    let index = 10;

4

5    let element = a[index];

6

7    println!("The value of element is: {}", element);

8}

9

编译阶段不会报错，在运行时会报错

1
2
3
4
5
6
7
8
9
1[root@itoracle src]# cargo build

2   Compiling datatype v0.1.0 (/usr/local/automng/src/rust/test/datatype)                                                 

3    Finished dev [unoptimized + debuginfo] target(s) in 1.39s                                                            

4[root@itoracle src]# cargo run

5    Finished dev [unoptimized + debuginfo] target(s) in 0.01s                                                            

6     Running `/usr/local/automng/src/rust/test/datatype/target/debug/datatype`

7thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:5:19

8note: Run with `RUST_BACKTRACE=1` for a backtrace.

9

转载于:https://www.cnblogs.com/perfei/p/10354783.html