基本数据类型 #

一、类型系统概述 #

Rust是静态类型语言，所有变量的类型在编译时必须确定。Rust的类型系统分为两大类：

  • 标量类型：整数、浮点、布尔、字符
  • 复合类型：元组、数组、结构体、枚举

二、整数类型 #

2.1 整数类型列表 #

类型 大小 范围
i8 8位 -128 ~ 127
u8 8位 0 ~ 255
i16 16位 -32768 ~ 32767
u16 16位 0 ~ 65535
i32 32位 -2^31 ~ 2^31-1
u32 32位 0 ~ 2^32-1
i64 64位 -2^63 ~ 2^63-1
u64 64位 0 ~ 2^64-1
i128 128位 -2^127 ~ 2^127-1
u128 128位 0 ~ 2^128-1
isize 指针大小 取决于架构
usize 指针大小 取决于架构

2.2 整数字面量 #

rust 
fn main() {
    // 十进制
    let decimal = 98_222;
    
    // 十六进制
    let hex = 0xff;
    
    // 八进制
    let octal = 0o77;
    
    // 二进制
    let binary = 0b1111_0000;
    
    // 字节（仅u8）
    let byte = b'A';
    
    println!("decimal: {}", decimal);
    println!("hex: {}", hex);
    println!("octal: {}", octal);
    println!("binary: {}", binary);
    println!("byte: {}", byte);
}

2.3 类型推断 #

rust 
fn main() {
    let x = 42;        // 默认推断为 i32
    let y: u64 = 100;  // 显式指定 u64
    
    println!("x: {}, y: {}", x, y);
}

2.4 整数溢出 #

在debug模式下，整数溢出会导致panic：

rust 
fn main() {
    let mut x: u8 = 255;
    // x += 1;  // debug模式下panic
    
    // 使用 wrapping_* 方法允许溢出
    let a: u8 = 255;
    let b = a.wrapping_add(1);
    println!("wrapping: {}", b);  // 0
    
    // 使用 checked_* 方法检查溢出
    let c: u8 = 255;
    match c.checked_add(1) {
        Some(v) => println!("result: {}", v),
        None => println!("overflow!"),
    }
    
    // 使用 saturating_* 方法饱和运算
    let d: u8 = 255;
    let e = d.saturating_add(1);
    println!("saturating: {}", e);  // 255
    
    // 使用 overflowing_* 方法返回溢出标志
    let f: u8 = 255;
    let (g, overflowed) = f.overflowing_add(1);
    println!("result: {}, overflowed: {}", g, overflowed);
}

2.5 整数运算 #

rust 
fn main() {
    let a: i32 = 10;
    let b: i32 = 3;
    
    println!("加法: {} + {} = {}", a, b, a + b);
    println!("减法: {} - {} = {}", a, b, a - b);
    println!("乘法: {} * {} = {}", a, b, a * b);
    println!("除法: {} / {} = {}", a, b, a / b);
    println!("取余: {} % {} = {}", a, b, a % b);
}

三、浮点类型 #

3.1 浮点类型 #

Rust有两种浮点类型：

类型 大小 精度
f32 32位 单精度（约6-7位有效数字）
f64 64位 双精度（约15-17位有效数字）
rust 
fn main() {
    let x = 2.0;      // 默认 f64
    let y: f32 = 3.0; // f32
    
    println!("x: {}, y: {}", x, y);
}

3.2 浮点运算 #

rust 
fn main() {
    let x = 2.5;
    let y = 3.0;
    
    println!("加法: {} + {} = {}", x, y, x + y);
    println!("减法: {} - {} = {}", x, y, x - y);
    println!("乘法: {} * {} = {}", x, y, x * y);
    println!("除法: {} / {} = {}", x, y, x / y);
    println!("取余: {} % {} = {}", x, y, x % y);
}

3.3 特殊值 #

rust 
fn main() {
    // 无穷大
    let inf = f64::INFINITY;
    let neg_inf = f64::NEG_INFINITY;
    
    // 非数字
    let nan = f64::NAN;
    
    println!("Infinity: {}", inf);
    println!("Negative Infinity: {}", neg_inf);
    println!("NaN: {}", nan);
    
    // 检查方法
    println!("is_nan: {}", nan.is_nan());
    println!("is_infinite: {}", inf.is_infinite());
    println!("is_finite: {}", 1.0_f64.is_finite());
}

3.4 数学函数 #

rust 
fn main() {
    let x = 2.0_f64;
    
    println!("sqrt: {}", x.sqrt());
    println!("abs: {}", (-x).abs());
    println!("pow: {}", x.powi(3));
    println!("floor: {}", 2.7_f64.floor());
    println!("ceil: {}", 2.3_f64.ceil());
    println!("round: {}", 2.5_f64.round());
    println!("sin: {}", std::f64::consts::PI.sin());
    println!("cos: {}", std::f64::consts::PI.cos());
}

四、布尔类型 #

4.1 布尔值 #

rust 
fn main() {
    let t = true;
    let f: bool = false;
    
    println!("true: {}", t);
    println!("false: {}", f);
}

4.2 布尔运算 #

rust 
fn main() {
    let a = true;
    let b = false;
    
    println!("a && b: {}", a && b);  // 逻辑与
    println!("a || b: {}", a || b);  // 逻辑或
    println!("!a: {}", !a);          // 逻辑非
}

4.3 比较运算 #

rust 
fn main() {
    let x = 5;
    let y = 10;
    
    println!("x == y: {}", x == y);
    println!("x != y: {}", x != y);
    println!("x < y: {}", x < y);
    println!("x > y: {}", x > y);
    println!("x <= y: {}", x <= y);
    println!("x >= y: {}", x >= y);
}

4.4 条件中使用 #

rust 
fn main() {
    let condition = true;
    
    if condition {
        println!("条件为真");
    } else {
        println!("条件为假");
    }
    
    // 布尔表达式
    let number = 6;
    let is_even = number % 2 == 0;
    println!("{} 是偶数: {}", number, is_even);
}

五、字符类型 #

5.1 字符定义 #

Rust的 char 类型是4字节，代表一个Unicode标量值：

rust 
fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart = '❤';
    let chinese = '中';
    
    println!("c: {}", c);
    println!("z: {}", z);
    println!("heart: {}", heart);
    println!("chinese: {}", chinese);
}

5.2 字符大小 #

rust 
fn main() {
    println!("char 大小: {} 字节", std::mem::size_of::<char>());
    // 输出：char 大小: 4 字节
    
    let c = 'A';
    println!("'{}' 的 Unicode: U+{:04X}", c, c as u32);
}

5.3 转义字符 #

rust 
fn main() {
    let newline = '\n';
    let tab = '\t';
    let backslash = '\\';
    let quote = '\'';
    let double_quote = '\"';
    
    // Unicode转义
    let unicode = '\u{1F600}';
    
    println!("newline: [{}]", newline);
    println!("tab: [{}]", tab);
    println!("unicode: {}", unicode);
}

5.4 字符方法 #

rust 
fn main() {
    let c = 'A';
    
    println!("is_alphabetic: {}", c.is_alphabetic());
    println!("is_numeric: {}", c.is_numeric());
    println!("is_alphanumeric: {}", c.is_alphanumeric());
    println!("is_lowercase: {}", c.is_lowercase());
    println!("is_uppercase: {}", c.is_uppercase());
    println!("is_whitespace: {}", c.is_whitespace());
    println!("is_ascii: {}", c.is_ascii());
    
    // 大小写转换
    println!("to_lowercase: {}", c.to_lowercase().next().unwrap());
    println!("to_uppercase: {}", 'a'.to_uppercase().next().unwrap());
}

5.5 字符与数字转换 #

rust 
fn main() {
    // 字符转数字
    let c = '5';
    let digit = c.to_digit(10);
    println!("digit: {:?}", digit);  // Some(5)
    
    // 数字转字符
    let num: u32 = 65;
    let char_from_num = char::from_u32(num);
    println!("char: {:?}", char_from_num);  // Some('A')
    
    // ASCII字符
    let ascii = 'A';
    println!("ASCII值: {}", ascii as u8);  // 65
}

六、类型别名 #

6.1 使用 type 关键字 #

rust 
type Kilometers = i32;
type Point = (i32, i32);

fn main() {
    let distance: Kilometers = 100;
    let point: Point = (10, 20);
    
    println!("Distance: {} km", distance);
    println!("Point: {:?}", point);
}

七、类型转换 #

7.1 as 关键字 #

rust 
fn main() {
    // 整数转换
    let a: i32 = 100;
    let b: i64 = a as i64;
    
    // 浮点转整数（截断）
    let c: f64 = 3.7;
    let d: i32 = c as i32;
    
    // 整数转浮点
    let e: i32 = 5;
    let f: f64 = e as f64;
    
    println!("i32 -> i64: {}", b);
    println!("f64 -> i32: {}", d);  // 3
    println!("i32 -> f64: {}", f);
}

7.2 TryInto trait #

rust 
use std::convert::TryInto;

fn main() {
    let big: i64 = 1_000_000_000;
    
    // 安全转换
    match big.try_into() {
        Ok(small) => println!("i32: {}", small),
        Err(e) => println!("转换失败: {}", e),
    }
}

八、实践示例 #

8.1 温度转换 #

rust 
fn main() {
    let celsius: f64 = 25.0;
    let fahrenheit = celsius * 9.0 / 5.0 + 32.0;
    
    println!("{}°C = {}°F", celsius, fahrenheit);
    
    let f: f64 = 77.0;
    let c = (f - 32.0) * 5.0 / 9.0;
    
    println!("{}°F = {}°C", f, c);
}

8.2 字符统计 #

rust 
fn main() {
    let text = "Hello, 世界!";
    let mut letter_count = 0;
    let mut digit_count = 0;
    let mut other_count = 0;
    
    for c in text.chars() {
        if c.is_alphabetic() {
            letter_count += 1;
        } else if c.is_numeric() {
            digit_count += 1;
        } else {
            other_count += 1;
        }
    }
    
    println!("字母: {}", letter_count);
    println!("数字: {}", digit_count);
    println!("其他: {}", other_count);
}

九、总结 #

本章学习了：

  • 整数类型及其字面量表示
  • 浮点类型和数学运算
  • 布尔类型和逻辑运算
  • 字符类型和Unicode支持
  • 类型别名和类型转换

Rust的类型系统保证了类型安全，理解基本类型是学习Rust的基础。下一章，我们将学习类型推断与转换。

最后更新：2026-03-27