Rust-数据类型【4】

数据类型

Rust 是 静态类型（statically typed）语言，也就是说在编译时就必须知道所有变量的类型

标量

标量类型代表一个单独的值

四种基本标量类型：

1. 整型
2. 浮点型
3. 布尔类型
4. 字符类型

整型

没有小数部分的数字 整型默认是 i32

长度	有符号	存储的数字范围	无符号	存储的数字范围
8-bit	i8	-128 至 127	u8	0 至 255
16-bit	i16	-32768 至 32767	u16	0 至 65535
32-bit	i32	-2147483648 至 2147483647	u32	0 至 4294967295
64-bit	i64	-9223372036854775808 至 9223372036854775807	u64	0 至 18446744073709551615
128-bit	i128	-170141183460469231731687303715884105728 至 170141183460469231731687303715884105727	u128	0 至 340282366920938463463374607431768211455
架构相关	isize	–	usize	–

fn main() {
  let a: i32 = 10;
  let b: usize = 6_000;
  println!("{}", a);
  println!("{}", b);
}

整型溢出：Rust 中整型溢出会导致 panic

• debug 模式下会 panic
• release 模式下会进行二进制补码溢出 例如: u8 溢出 此类型能容纳最大值还大的值会回绕到最小值，值 256 变成 0，值 257 变成 1，依此类推。程序不会 panic

浮点型

Rust 有两个原生的 浮点数类型，它们是带小数点的数字。Rust 的浮点数类型是 f32 和 f64，分别占 32 位和 64 位。默认类型是 f64，因为在现代 CPU 中，它与 f32 速度几乎一样，不过精度更高。所有的浮点型都是有符号的

fn main() {
  let x = 2.0; // f64

  let y: f32 = 3.0; // f32
}

浮点数采用 IEEE-754 标准表示。（f32 是单精度浮点数，f64 是双精度浮点数。）

数值运算

fn main() {
    // 加
    let sum = 5 + 10;

    // 减
    let difference = 95.5 - 4.3;

    // 乘
    let product = 4 * 30;

    // 除
    let quotient = 56.7 / 32.2;
    let truncated = -5 / 3; // 结果为 -1

    // 取余
    let remainder = 43 % 5;
}

布尔类型

Rust 中的布尔类型使用 bool 表示

fn main() {
    let t = true;

    let f: bool = false;
}

字符类型

Rust 的 char 类型表示单个 Unicode 标量值，占用 4 个字节（32 位），可以表示从 U+0000 到 U+10FFFF 范围内的任何 Unicode 字符。这意味着它可以表示不仅仅是 ASCII 字符，还包括中文、日文、表情符号等

fn main() {
  // 单引号 ' 用于字符（char）
    let c = 'z';
    let z: char = 'Z';
    println!("{}", c);
    println!("{}", z);
  // 双引号 " 用于字符串
  let s = "hello";
  let s2: &str = "hello";
}

注意：单引号 双引号 必须严格区分

• 字符串可以为空（如 “”），但不能用单引号包裹（如 ‘’ 会报错）

常见错误示例

// 错误示例：用单引号包裹多个字符
let invalid_char: char = 'AB';  // 编译错误：预期单个字符

// 错误示例：用双引号定义字符
let also_invalid: char = "A";   // 编译错误：类型不匹配（"A" 是 &str）

// 正确示例：字符串可以包含多个字符
let valid_string: &str = "ABC";

复合类型

复合类型可以将多个值组合成一个类型

元组

元组是一个可以包含多个不同类型值的复合类型。元组的长度是固定的，一旦创建，就不能改变。

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    // 解构
    let (x, y, z) = tup;
    println!("The value of y is: {y}");
    // 也可以使用点号（.）后跟值的索引来直接访问所需的元组元素
    println!("The value of z is: {}", tup.2);
}

数组

数组是一个固定长度的、相同类型的元素集合

fn main() {
    let a = [1, 2, 3];
    // 方括号中包含每个元素的类型，后跟分号，再后跟数组元素的数量
    // 这里，i32 是每个元素的类型。分号之后，数字 3 表明该数组包含三个元素
    let b: [i32; 3] = [1, 2, 3];
    // 通过在方括号中指定初始值加分号再加元素个数的方式来创建一个每个元素都为相同值的数组
    let c = [3; 5]; // let c = [3, 3, 3, 3, 3]
    // 访问数组元素
    let first = a[0];
    let second = a[1];
}