006 Rust基本数据类型
整数型（Integer）
整数型简称整型，按照比特位长度和有无符号分为以下两种类：
有符号整数 (i): 可以表示正数、负数和零。以二进制补码形式存储。
无符号整数 (u): 只能表示正数和零。
Rust 提供了多种不同大小的整数类型，由 i或 u后面的数字表示该类型占用的位数（决定了其取值范围）。
| 位长度 | 有符号 | 无符号 | 最小值（有符号） | 最大值（有符号） | 最大值（无符号） |
|---|---|---|---|---|---|
| 8-bit | i8 | u8 | -128 | 127 | 255 |
| 16-bit | i16 | u16 | -32768 | 32767 | 65535 |
| 32-bit | i32 | u32 | -2147483648 | 2147483647 | 4294967295 |
| 64-bit | i64 | u64 | -2^63 | 2^63 - 1 | 2^64 - 1 |
| 128-bit | i128 | u128 | -2^127 | 2^127 - 1 | 2^128 - 1 |
| arch | isize | usize | 依赖平台 | 依赖平台 | 依赖平台 |
isize和 usize 这两种类型的长度取决于程序运行的计算机架构。在 64 位架构上是 64 位，在 32 位架构上是 32 位。它们通常用于表示索引、集合的大小或内存地址（指针）。
| 进制 | 例 |
|---|---|
| 十进制 | 98_123 |
| 十六进制 | 0xff |
| 八进制 | 0o77 |
| 二进制 | 0b1111_0000 |
| 字节（只能表示u8类型） | b’A’ |
整数中间存在一个下划线，这种设计可以让人们在输入一个很大的数字时更容易判断数字的值大概是多少。
可以在字面量后加类型后缀指定类型 如57u8。
当编译器无法推断整数类型时，默认使用 i32。
let a: i32 = 42; // 显示类型声明有符号32位整数
let b: u64 = 100_000; // 显示类型声明无符号64位整数（可用_分隔）
let c = 50i8; // 后缀i8类型
let d = 300u16; // 后缀u16类型
let e = 0xffu32; // 后缀十六进制 u32
let f = 0o77_i64; // 后缀八进制 i64
let g = 0b1110_0000u8; // 后缀二进制 u8（带分隔符）
let h = 42; // 编译器推断为 i32
let pointer_size: isize = -10; // 与指针同宽（通常用于索引）
let size: usize = 1024; // 无符号平台相关类型
浮点数型（Floating-Point）
浮点数型即带有小数部分的数字。
Rust支持 32 位浮点数（f32）和 64 位浮点数（f64）。
- f32: 32 位单精度浮点数。
- f64: 64 位双精度浮点数。
默认类型： Rust 的浮点数默认类型是 f64。因为在现代 CPU 上，f64的速度与 f32几乎相同，但 64 位浮点数精度更高。
字面量表示：
- 标准： 3.14, 0.1
- 科学计数法： 6.022e23, 1e-6
- 可以加后缀： 2.0f32
// 方式 1：显式类型注解
let float_32: f32 = 3.14159;
// 方式 2：类型后缀
let float_32 = 3.14159f32;
// 方式 3：函数返回值类型
fn get_pi() -> f32 {3.14159
}
// 方式 1：显式类型注解
let float_64: f64 = 3.141592653589793;
// 方式 2：类型后缀
let float_64 = 3.141592653589793f64;
// 方式 3：默认类型（不指定类型时自动推断为 f64）
let default_float = 3.14; // 编译器自动推断为 f64
布尔型
布尔型用 bool 表示，值只能为 true 或 false。
let is_rust_fast: bool = true; // 显式声明类型
let is_java_fast: bool = false; // 显式声明类型
let is_sunny = true; // 编译器自动推断为 bool
let is_raining = false; // 编译器自动推断为 bool
Rust 的布尔类型是严格的，不能像 C/C++ 那样将数值当作布尔值使用。
如果需要将布尔值转换为整数，需要显式转换：
let true_as_int = true as i32; // 1
let false_as_int = false as i32; // 0
字符型（char）
表示单个 Unicode 标量值，占4 个字节（32 位）， 可以表示比 ASCII 丰富得多的字符集，包括各种语言的字母、表情符号等。
字面量表示： 用单引号 '括起来： ‘A’, ‘z’, ‘ф’, ‘猫’。
注意： 这与用双引号 "括起来的字符串切片 &str或 String类型不同。char是单个字符，字符串是字符序列。一般推荐使用字符串储存 UTF-8 文字（非英文字符尽可能地出现在字符串中）。
由于中文文字编码有两种（GBK 和 UTF-8），所以编程中使用中文字符串有可能导致乱码的出现，这是因为源程序与命令行的文字编码不一致，所以在 Rust 中字符串和字符都必须使用 UTF-8 编码，否则编译器会报错。
let letter = 'A'; // 英文字母
let digit = '7'; // 数字字符
let symbol = '$'; // 符号
let space = ' '; // 空格
let chinese: char = '中'; // 中文字符
let emoji: char = '😊'; // 表情符号
let heart = '\u{2764}'; // ❤ 使用 Unicode 码点
let omega = '\u{03A9}'; // Ω 希腊字母
let newline = '\n'; // 换行符
let tab = '\t'; // 制表符
let single_quote = '\''; // 单引号本身
let backslash = '\\'; // 反斜杠
let ascii_a = b'A' as char; // 从字节转换为 char（仅适用于 ASCII 字符）
常见操作：
1、检查字符属性
let c = 'A';
assert!(c.is_alphabetic()); // 是否是字母
assert!(c.is_ascii()); // 是否是 ASCII 字符
assert!(!c.is_numeric()); // 是否是数字
2、大小写转换
let lower = 'a';
let upper = lower.to_ascii_uppercase(); // 'A'let upper = 'B';
let lower = upper.to_ascii_lowercase(); // 'b'
3、转换为数字
let digit = '7';
let num = digit.to_digit(10); // Some(7)let hex_digit = 'F';
let num = hex_digit.to_digit(16); // Some(15)
4、模式匹配
match some_char {'a'..='z' => println!("小写字母"),'A'..='Z' => println!("大写字母"),'0'..='9' => println!("数字"),_ => println!("其他字符"),
}
注意事项：
1、字符字面量不能为空（''是无效语法）。
2、多字符（如字符串）不能赋值给 char类型。
复合类型
复合类型可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组和数组。
1、元组 (Tuple)
定义： 将多个不同类型的值组合成一个复合类型的通用方法。
语法： 使用圆括号 () 将值括起来，值之间用英文逗号 ,分隔。每个位置可以有不同的类型。
特点：长度固定，一旦声明，其长度和元素的类型就不能改变。
// 声明元组
let var:(T1, T2, ..., Tn); // 固定长度，可包含不同类型 (T1, T2...) 的值
let tup: (i32, f64, u8) = (500, 6.4, 1); // 显式类型注解
let tup = (500, 6.4, 1); // 类型推断
获取元组中的值
- 模式匹配解构：
let (x, y, z) = tup; // x = 500, y = 6.4, z = 1
- 点号 .加索引
let one = tup.0; // 访问第一个元素 (索引从0开始)
let two = tup.1;
let three = tup.2;
2、数组 (Array)
定义： 将多个相同类型的值组合成一个集合。
语法： 使用方括号 []将值括起来，值之间用英文逗号 ,分隔。数组的类型写作 [T; N]，其中 T是元素类型，N是编译时确定的固定长度。
// 声明数组
let var:[T; N]; // 固定长度 N，所有元素必须是相同类型 T，在栈上分配，长度固定
let a: [i32; 5] = [1, 2, 3, 4, 5]; // 显式声明类型
let a = [1, 2, 3, 4, 5]; // 类型推断为 [i32; 5]
let b = [3; 5]; // 等同于 [3, 3, 3, 3, 3]，类型是 [i32; 5]
获取数组值
使用方括号 []加索引。索引从 0 开始。
let first = a[0]; // 1
let second = a[1]; // 2