Rust 数据类型

Rust 是一种静态类型语言，这意味着在编译时就必须明确每个变量的类型。Rust 提供了丰富的数据类型，可分为基本数据类型和复合数据类型。

基本数据类型

整数类型

整数类型表示没有小数部分的数字。Rust 提供了多种整数类型，根据位数和有无符号进行区分。

长度	有符号	无符号
8 位	i8	u8
16 位	i16	u16
32 位	i32	u32
64 位	i64	u64
128 位	i128	u128
视架构而定	isize	usize

示例代码：

fn main() {
    let a: i32 = 42; 
    let b: u8 = 255; 
    println!("a: {}, b: {}", a, b); 
} 

浮点类型

Rust 有两种浮点类型，即 f32（单精度）和 f64（双精度）。默认情况下，浮点数字面量会被推断为 f64 类型。 示例代码：

fn main() { 
    let x: f32 = 3.14;
    let y = 2.71828;
    // 推断为 f64 类型
    println!("x: {}, y: {}", x, y);
}

布尔类型

布尔类型只有两个可能的值：true 和 false，使用 bool 表示。 示例代码：

fn main() {
    let is_valid: bool = true; 
    println!("Is valid: {}", is_valid); 
} 

字符类型

Rust 的 char 类型用于表示单个 Unicode 标量值，使用单引号括起来。 示例代码：

fn main() {
    let c: char = 'A'; 
    let emoji: char = '😀'; 
    println!("c: {}, emoji: {}", c, emoji);
} 

复合数据类型

元组类型

元组是将多个不同类型的值组合在一起的复合类型，其长度固定。 示例代码：

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1); 
    let (x, y, z) = tup; 
    // 解构元组 
    println!("x: {}, y: {}, z: {}", x, y, z); 
    // 也可以通过索引访问元组元素 
    println!("tup.0: {}", tup.0); 
} 

数组类型

数组是一组相同类型的值的集合，其长度也是固定的。 示例代码：

fn main() { 
    let a: [i32; 5] = [1, 2, 3, 4, 5]; 
    println!("a[0]: {}", a[0]); // 初始化所有元素为相同值 
    let b = [3; 5]; // 创建一个包含 5 个元素，每个元素值为 3 的数组 
    println!("b: {:?}", b);
} 

自定义数据类型

结构体类型

结构体允许你将多个相关的字段组合在一起，形成一个自定义的数据类型。 示例代码：

struct User {
    username: String, 
    email: String, 
    sign_in_count: u64, 
    active: bool, 
} 
fn main() { 
    let user1 = User { 
        email: String::from("someone@example.com"),
        username: String::from("someusername123"), 
        active: true, sign_in_count: 1, 
    }; 
    println!("User email: {}", user1.email); 
} 

枚举类型

枚举类型允许你定义一组可能的值。 示例代码：

enum IpAddrKind { 
    V4, V6, 
} 
struct IpAddr { 
    kind: IpAddrKind, 
    address: String, 
} 
fn main() { 
    let home = IpAddr { 
        kind: IpAddrKind::V4, 
        address: String::from("127.0.0.1"), 
    };
    println!("Home IP address: {}", home.address); 
} 

类型推断与类型注解

Rust 编译器通常能够根据上下文推断出变量的类型，但在某些情况下，你可能需要显式地提供类型注解。 示例代码：

fn main() { 
    let num = 42; // 类型推断为 i32 
    let num_with_annotation: u32 = 42; // 显式类型注解 
} 

通过这些丰富的数据类型，Rust 为开发者提供了强大的类型系统，有助于编写安全、高效的代码。