【Rust 基础篇】Rust数据类型详解_rust bool

导言

Rust是一种现代的、安全的系统编程语言，注重内存安全和并发性。在Rust中，数据类型是程序中最基本的构建块之一。本篇博客将详细解释Rust的各种数据类型，并提供相关代码示例。

一、基本数据类型

Rust的基本数据类型包括布尔类型、整数类型、浮点类型和字符类型。

1、布尔类型（bool）

布尔类型在Rust中用于表示逻辑值，有两个可能的取值：true和false。在Rust中，布尔类型的大小为1个字节。

以下是一个布尔类型的示例：

fn main() {
    let is_true: bool = true;
    let is_false: bool = false;

    println!("is_true: {}", is_true);
    println!("is_false: {}", is_false);
}
1
2
3
4
5
6
7

2、整数类型

Rust提供了多种整数类型，包括有符号和无符号整数类型。有符号整数类型可以表示正数、负数和零，而无符号整数类型只能表示非负数和零。

• i8：有符号8位整数类型
• u8：无符号8位整数类型
• i16：有符号16位整数类型
• u16：无符号16位整数类型
• i32：有符号32位整数类型
• u32：无符号32位整数类型
• i64：有符号64位整数类型
• u64：无符号64位整数类型
• i128：有符号128位整数类型
• u128：无符号128位整数类型
• isize：有符号指针大小整数类型
• usize：无符号指针大小整数类型

以下是一些常用整数类型的示例：

fn main() {
    let a: i8 = 42;
    let b: u16 = 100;
    let c: i32 = -500;
    let d: u64 = 1000;

    println!("a: {}", a);
    println!("b: {}", b);
    println!("c: {}", c);
    println!("d: {}", d);
}
1
2
3
4
5
6
7
8
9
10
11

3、浮点类型

Rust提供了两种浮点类型：f32和f64，分别表示单精度和双精度浮点数。f32是32位浮点数，f64是64位浮点数。

以下是一个浮点类型的示例：

fn main() {
    let x: f32 = 3.14;
    let y: f64 = 2.71828;

    println!("x: {}", x);
    println!("y: {}", y);
}
1
2
3
4
5
6
7

4、字符类型

在Rust中，字符类型用char表示，它是Unicode标量值的32位表示。字符类型的大小为4个字节。

以下是一个字符类型的示例：

fn main() {
    let c: char = 'A';
    let heart_emoji: char = '❤';

    println!("c: {}", c);
    println!("heart_emoji: {}", heart_emoji);
}
1
2
3
4
5
6
7

二、复合数据类型

Rust提供了几种复合数据类型，包括元组、数组和字符串。

1、元组（Tuple）

元组是Rust中的一种复合数据类型，它可以将多个不同类型的值组合在一起。元组使用圆括号()表示，其中的值可以通过索引访问。

以下是一个元组的示例：

fn main() {
    let person: (String, i32, bool) = ("Alice".to_string(), 25, true);

    println!("Name: {}", person.0);
    println!("Age: {}", person.1);
    println!("Is employed: {}", person.2);
}
1
2
3
4
5
6
7

2、数组（Array）

数组是一种固定长度的数据结构，它可以存储相同类型的多个值。在Rust中，数组的长度是固定的，且数组的类型由元素类型和长度决定。

以下是一个数组的示例：

fn main() {
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];

    for number in numbers.iter() {
        println!("Number: {}", number);
    }
}
1
2
3
4
5
6
7

3、字符串（String）

字符串是一种文本数据类型，它由一系列Unicode字符组成。在Rust中，字符串类型使用String表示，它是一个可增长的、可变的字符串类型。

以下是一个字符串的示例：

fn main() {
    let message: String = String::from("Hello, Rust!");

    println!("Message: {}", message);
}
1
2
3
4
5

三、自定义数据类型

Rust允许用户自定义数据类型，包括结构体和枚举。

1、结构体（Struct）

结构体是一种自定义的数据类型，它可以将多个不同类型的值组合在一起形成一个新的类型。结构体使用struct关键字定义，并可以包含字段（field）和方法（method）。

以下是一个结构体的示例：

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle {
        width: 10,
        height: 20,
    };

    println!("Area: {}", rect.area());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2、枚举（Enum）

枚举是一种自定义的数据类型，它可以表示多个可能的值。枚举使用enum关键字定义，并可以包含不同的变体（variant）。

以下是一个枚举的示例：

enum Fruit {
    Apple,
    Banana,
    Orange,
}

fn main() {
    let fruit: Fruit = Fruit::Apple;

    match fruit {
        Fruit::Apple => println!("It's an apple!"),
        Fruit::Banana => println!("It's a banana!"),
        Fruit::Orange => println!("It's an orange!"),
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

四、其他数据类型

除了基本数据类型、复合数据类型和自定义数据类型，Rust还提供了其他一些常用的数据类型。

1、切片（Slice）

切片是对数组或字符串的引用，它允许我们引用集合中的一部分而不用拷贝整个集合。切片使用&符号和范围表示。

以下是一个切片的示例：

fn main() {
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    let slice: &[i32] = &numbers[1..3];

    println!("Slice: {:?}", slice);
}
1
2
3
4
5
6

2、Option类型

Option类型在Rust中用于表示可能为空的值。它有两个可能的取值：Some(value)表示有值，None表示无值。Option类型可以帮助我们处理可能出现空值的情况。

以下是一个Option类型的示例：

fn divide(x: f64, y: f64) -> Option<f64> {
    if y != 0.0 {
        Some(x / y)
    } else {
        None
    }
}

fn main() {
    let result = divide(10.0, 2.0);

    match result {
        Some(value) => println!("Result: {}", value),
        None => println!("Cannot divide by zero"),
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3、Result类型

Result类型在Rust中用于处理可能发生错误的操作。它有两个可能的取值：Ok(value)表示操作成功，返回一个值，Err(error)表示操作失败，返回一个错误。

以下是一个Result类型的示例：

fn divide(x: f64, y: f64) -> Result<f64, String> {
    if y != 0.0 {
        Ok(x / y)
    } else {
        Err("Cannot divide by zero".to_string())
    }
}

fn main() {
    let result = divide(10.0, 2.0);

    match result {
        Ok(value) => println!("Result: {}", value),
        Err(error) => println!("Error: {}", error),
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

总结

本篇博客介绍了Rust的各种数据类型，包括布尔类型、整数类型、浮点类型、字符类型、元组、数组、字符串、结构体、枚举、切片、Option类型和Result类型。对于每种数据类型，都提供了相应的代码示例和详细解释。熟悉并理解Rust的数据类型是编写安全、高效程序的基础。

希望本篇博客对你学习和使用Rust有所帮助！