Rust -数据类型

Rust数据类型

Rust数据类型分为标量类型和复合类型，Rust是一门静态编译语言，在编译时必须知道所有变量的类型，当然编译器可以基于使用的值推断出它的数据类型，但是出现可能的类型较多的话，那么我们就必须为变量标注数据类型，否则编译器是会报错的

---

标量类型

标量类型分为整数类型、浮点类型、布尔类型以及字符类型四种

---

整数类型

以u32举例，他就是一个无符号的整数类型，无符号意思就是不区分正负符号，该类型变量将占据32位空间，也就是范围在 0 ~ 2^32-1

• 无符号整数类型指的就是以u开头的数据类型标注(范围：0 ~ 2^n-1)
• 有符号类型则以i开头(范围：-(2ⁿ-1) ~ 2^n-1-1)

等等，arch是什么？ 🤔 arch指的是根据系统架构来自动分配空间，比如我们使用64位计算机，那么arch就会开辟一个64位的空间，当然这个并不常用，主要就是对某一种集合进行索引操作

除了字节类型以外，也就是byte类型之外，所有的数值字面量都允许使用类型后缀（67u8），如果你真的不知道该使用那种类型，不如就使用Rust的默认类型吧（i32），整体来说的话，并不会影响多少速度，哪怕我们身处64位计算机中

fn main() {
    let test_num:u8 = 255;
    println!("输出{}",test_num);
}
1
2
3
4

如果我们的空间不能够存放变量会怎样？
这个问题我们还是比较注重的，假如我们有一个范围为0 ~ 255的U8类型，不巧的是我们给了一个256，那么这时会发生什么？

• 在调试模式之下进行编译的话，Rust 会检查整数溢出、如果确实发生了像这样的整数溢出情况的话，程序在运行时会panic
• 如果时在发布模式之下（也就是 --release）编译的话，Rust是不会检查可能导致恐慌的整数溢出的，如果发生溢出，那么Rust 会执行一种环绕操作，256将变为0，257将变为1，258将变为2依次环绕，但是程序不会panic的

---

浮点类型

Rust有俩种基础的浮点类型：

• f32则是单精度32位
• f64则是双精度64位

Rust的浮点类型使用了 IEEE-754标准表述，和整数类型不同的是，浮点数的默认类型是f64，因为现在CPU很强大，64或者32的速度相差无几，反而64位精度更高

fn main() {
    let test_num:f32 = 255.5555555555555;
    println!("输出{}",test_num);
}
// 输出255.55556
1
2
3
4
5

fn main() {
    let test_num:f64 = 255.5555555555555;
    println!("输出{}",test_num);
}
// 输出255.5555555555555
1
2
3
4
5

---

布尔类型

这好像没有什么可介绍的，额~ 它占据一个字节

fn main() {
    let test_num:bool = true;
    println!("输出{}",test_num);
}
// 输出true
1
2
3
4
5

---

字符类型

Rust语言中 char 类型被用来描述语言中最基础的单个字符，字面量使用单引号，占用四个字节，它是Unicode标量值，可以表示比ASCII码多很多的字符内容，比如表情符、韩文、日文等等

fn main() {
    let test_num:char = '😁';
    println!("输出{}",test_num);
}
// 输出😁
1
2
3
4
5

需要注意的是Unicode中并没有字符概念、所以直觉上认为的字符也许与Rust中的概念并不相等

---

复合类型

Rust提供了俩种基础的复合类型：元组（Tuple）、数组

---

Tuple

Tuple可将多个类型的多个值放在一个类型中，它的长度是固定的并且一旦声明之后就无法改变

创建Tuple需要在小括号内将值用逗号分开，Tuple的每个位置都对应一个类型，Tuple中的各元素的类型可以不同

fn main() {
    let test_num:(i32,u8,f32,bool,char) = (-20,20,22.22,true,'😎');
    println!("输出{}--{}--{}--{}--{}",test_num.0,test_num.1,test_num.2,test_num.3,test_num.4);
}
// 输出-20--20--22.22--true--😎
1
2
3
4
5

---

解构获取Tuple值

我们获取Tuple值可以通过模式匹配来解构一个Tuple获取到元素值

fn main() {
    let test_num:(i32,u8,f32,bool,char) = (-20,20,22.22,true,'😎');
    println!("输出{}--{}--{}--{}--{}",test_num.0,test_num.1,test_num.2,test_num.3,test_num.4);

    let (a,b,c,d,e) = test_num;
    println!("{}{}",a,e)
}
// 输出-20--20--22.22--true--😎
// -20😎
1
2
3
4
5
6
7
8
9

---

数组

数组也可以将多个值放在一个类型中，但不同于Tuple的是：数组中的每个元素的类型必须相同，数组的长度也是固定的，也就是说当我们想将数据存放在stack上而不是heap上，或者想保证有固定数量的元素，这时使用数组更有好处

// 数组中的值不同时
fn main() {
    let arr: [i64;4] = [21,2,3,4];
    println!("{}",arr[3]);
}
// 数组中的值相同时
fn main() {
    let arr = [8;4];
    println!("{}",arr[3]);
}
1
2
3
4
5
6
7
8
9
10

如果我们访问的索引超出了数组的范围，那么运行时会报错，编译会通过，Rust不会允许其继续访问相应地址的内存

好吧，如果我们对于数据长度是否可修改有需求的话，可以使用Vector，它更加灵活，与数组类似由标准库提供，主要是它的长度可以改变