rust学习-rust中的保留字

已使用的保留字
未来可能使用的保留字

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

已使用的保留字

as：用于类型转换

rust 复制代码

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

break：用于终止循环

rust 复制代码

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

const：用于定义常量

rust 复制代码

const MAX_POINTS: u32 = 100_000;

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

rust 复制代码

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

crate：用于指定 crate 根模块

rust 复制代码

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

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

rust 复制代码

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);

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

rust 复制代码

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

enum：用于定义枚举类型

rust 复制代码

enum Color {
    Red,
    Green,
    Blue,
}

let color = Color::Red;

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

rust 复制代码

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

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

false：布尔常量，表示假

rust 复制代码

let is_false = false;

fn：用于定义函数

rust 复制代码

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

let sum = add(5, 3);

for：用于循环

rust 复制代码

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

if：用于条件语句

rust 复制代码

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

impl：用于实现方法或 trait

rust 复制代码

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));

in：用于 for 循环或 match 语句

rust 复制代码

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

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

let：用于声明变量

rust 复制代码

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

loop：用于无限循环

rust 复制代码

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

match：用于模式匹配

rust 复制代码

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

mod：用于定义模块

rust 复制代码

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

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

move：用于闭包捕获环境

rust 复制代码

let x = 5;
let y = 10;

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

closure();

mut：用于声明可变变量

rust 复制代码

let mut x = 5;
x = 10;

pub：用于声明公共项

rust 复制代码

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

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

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

rust 复制代码

let x = 5;
let ref_x = &x;

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

return：用于从函数返回值

rust 复制代码

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

let sum = add(5, 3);

self：用于表示当前实例

rust 复制代码

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());

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

rust 复制代码

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

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

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

static：用于定义静态变量

rust 复制代码

static X: i32 = 5;

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

struct：用于定义结构体

rust 复制代码

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

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

super：用于访问父模块

rust 复制代码

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();
}

trait：用于定义 trait

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

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);

true：布尔常量，表示真

rust 复制代码

let is_true = true;

type：用于定义类型别名

rust 复制代码

type Kilometers = i32;

let distance: Kilometers = 5;

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

rust 复制代码

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

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

use：用于引入模块

rust 复制代码

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

use my_mod::say_hello;

fn main() {
    say_hello();
}

where：用于指定 trait 约束

rust 复制代码

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

fn main() {
    some_func(5);
}

未来可能使用的保留字

abstract
become
box
do
final
macro
override
priv
typeof
unsized
virtual
yield