rust学习-rust中的保留字

保留字是语言中预定义的标识符，不能用作变量名、函数名或其他自定义标识符，Rust的保留字大致可以分为两类：已使用的保留字和未来可能使用的保留字

已使用的保留字

1. as：用于类型转换

let num: i32 = 5;
let float_num = num as f64;

2. break：用于终止循环

loop {
    println!("再次循环");
    break;
}

3. const：用于定义常量

const MAX_POINTS: u32 = 100_000;

4. continue：用于跳过当前循环的剩余部分并开始下一次迭代

for i in 0..10 {
    if i % 2 == 0 {
        continue;
    }
    println!("奇数: {}", i);
}

5. crate：用于指定 crate 根模块

// 在 Cargo.toml 中定义 crate
// Cargo.toml
[package]
name = "my_crate"
version = "0.1.0"

6. dyn：用于动态分发的 trait 对象

trait Draw {
    fn draw(&self);
}

struct Rectangle;

impl Draw for Rectangle {
    fn draw(&self) {
        println!("绘制矩形");
    }
}

fn draw_item(item: &dyn Draw) {
    item.draw();
}

let rectangle = Rectangle;
draw_item(&rectangle);

7. else：用于条件语句中的 if 之后的分支

let x = 5;
if x == 5 {
    println!("x 是 5");
} else {
    println!("x 不是 5");
}

8. enum：用于定义枚举类型

enum Color {
    Red,
    Green,
    Blue,
}

let color = Color::Red;

9. extern：用于定义外部函数或链接外部库

extern "C" {
    fn printf(format: *const u8, ...) -> i32;
}

fn main() {
    unsafe {
        printf(b"Hello, World!\0".as_ptr());
    }
}

10. false：布尔常量，表示假

let is_false = false;

11. fn：用于定义函数

fn add(a: i32, b: i32) -> i32 {
    a + b
}

let sum = add(5, 3);

12. for：用于循环

for i in 0..3 {
    println!("i: {}", i);
}

13. if：用于条件语句

let x = 5;
if x > 0 {
    println!("x 是正数");
}

14. impl：用于实现方法或 trait

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    fn distance(&self, other: &Point) -> f64 {
        (((self.x - other.x).pow(2) + (self.y - other.y).pow(2)) as f64).sqrt()
    }
}

let p1 = Point::new(0, 0);
let p2 = Point::new(3, 4);
println!("距离: {}", p1.distance(&p2));

15. in：用于 for 循环或 match 语句

for i in 0..3 {
    println!("i: {}", i);
}

match 2 {
    1 => println!("一是 1"),
    2 => println!("二是 2"),
    _ => println!("其他"),
}

16. let：用于声明变量

let x = 5;
let y: i32 = 10;

17. loop：用于无限循环

loop {
    println!("再次循环");
    break;
}

18. match：用于模式匹配

let x = 2;
match x {
    1 => println!("一是 1"),
    2 => println!("二是 2"),
    _ => println!("其他"),
}

19. mod：用于定义模块

mod my_module {
    pub fn say_hello() {
        println!("Hello from my_module!");
    }
}

fn main() {
    my_module::say_hello();
}

20. move：用于闭包捕获环境

let x = 5;
let y = 10;

let closure = move || {
    println!("x: {}, y: {}", x, y);
};

closure();

21. mut：用于声明可变变量

let mut x = 5;
x = 10;

22. pub：用于声明公共项

pub fn public_function() {
    println!("这是公共函数");
}

mod my_mod {
    pub fn public_function() {
        println!("这是 my_mod 中的公共函数");
    }
}

23. ref：用于在模式匹配中获取引用

let x = 5;
let ref_x = &x;

match ref_x {
    ref r => println!("r 是引用: {:?}", r),
}

24. return：用于从函数返回值

fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

let sum = add(5, 3);

25. self：用于表示当前实例

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Self {
        Point { x, y }
    }

    fn distance_from_origin(&self) -> f64 {
        (self.x.pow(2) + self.y.pow(2)) as f64
    }
}

let p = Point::new(3, 4);
println!("距离原点: {}", p.distance_from_origin());

26. Self：用于表示当前类型的自身

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }
}

let p = Point::new(3, 4);

27. static：用于定义静态变量

static X: i32 = 5;

fn main() {
    println!("X: {}", X);
}

28. struct：用于定义结构体

struct Point {
    x: i32,
    y: i32,
}

let p = Point { x: 3, y: 4 };

29. super：用于访问父模块

mod outer {
    pub fn outer_fn() {
        println!("outer_fn");
    }

    mod inner {
        pub fn inner_fn() {
            super::outer_fn();
            println!("inner_fn");
        }
    }
}

fn main() {
    outer::inner::inner_fn();
}

30. trait：用于定义 trait

trait（特性）是一种定义共享行为的方式，它类似于其他编程语言中的接口（interface），但更加灵活和强大，trait可定义一组方法签名，这些方法可以在不同的类型中实现，通过这种方式，Rust能够实现多态性，并确保类型安全

trait Draw {
    fn draw(&self);
}

struct Rectangle;

impl Draw for Rectangle {
    fn draw(&self) {
        println!("绘制矩形");
    }
}

fn draw_item(item: &impl Draw) {
    item.draw();
}

let rectangle = Rectangle;
draw_item(&rectangle);

31. true：布尔常量，表示真

let is_true = true;

32. type：用于定义类型别名

type Kilometers = i32;

let distance: Kilometers = 5;

33. unsafe：用于编写不安全的代码

unsafe fn dangerous() {
    println!("这是不安全的代码");
}

fn main() {
    unsafe {
        dangerous();
    }
}

34. use：用于引入模块

mod my_mod {
    pub fn say_hello() {
        println!("Hello from my_mod!");
    }
}

use my_mod::say_hello;

fn main() {
    say_hello();
}

35. where：用于指定 trait 约束

fn some_func<T: std::fmt::Display>(t: T) where T: std::fmt::Debug {
    println!("t: {:?}", t);
}

fn main() {
    some_func(5);
}

未来可能使用的保留字

1. abstract
2. become
3. box
4. do
5. final
6. macro
7. override
8. priv
9. typeof
10. unsized
11. virtual
12. yield

这些保留字目前在 Rust 中没有具体的用途，但它们被预留以备将来扩展语言时使用