简单的Rust编程语言初级教程

Rust 简介

Rust 是一门专注于安全性和性能的系统编程语言。它可以帮助开发者编写高效、安全的代码。

安装 Rust

1. 安装 Rust： 可以通过 Rust 官方网站的 Rustup 安装工具安装 Rust。

2. 检查安装： 安装完成后，可以在终端中运行以下命令来验证安装是否成功：

   rustc --version

基本语法

Hello, World!

创建一个名为 main.rs 的文件，并输入以下代码：

fn main() {
    println!("Hello, world!");
}

运行程序：

rustc main.rs
./main

变量和可变性

fn main() {
    let x = 5; // 不可变变量
    let mut y = 10; // 可变变量
    y = 15;
    println!("x: {}, y: {}", x, y);
}

数据类型

Rust 是静态类型语言，常见的数据类型包括：

• 整数：i8, u8, i32, u32, 等
• 浮点数：f32, f64
• 布尔：bool
• 字符：char
• 元组和数组

fn main() {
    let a: i32 = 10;
    let b: bool = true;
    let c: char = 'z';
    let d: (i32, f64, u8) = (500, 6.4, 1);
    let e: [i32; 3] = [1, 2, 3];
}

函数

fn main() {
    let result = add(5, 10);
    println!("Result: {}", result);
}

fn add(x: i32, y: i32) -> i32 {
    x + y
}

控制流

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else {
        println!("number is not divisible by 4 or 3");
    }

    // 循环
    for i in 1..5 {
        println!("{}", i);
    }
}

练习

1. 创建一个函数，计算两个数的乘积。

   
   fn mul(x: i32, y: i32) -> i32 {return x * y;}
   fn main() {
   println!("Result: {}", mul(9, 9));
   }

2. 使用 for 循环打印从 1 到 100 的所有偶数。
```rust
fn main() {
    for i in 1..=100 {
        if i % 2 == 0 {
            println!("{}", i);
        }
    }
}

总结

在 Rust 中，函数的最后一个表达式的返回值可以省略 return 关键字。最后一个表达式会被自动作为返回值。

fn add(x: i32, y: i32) -> i32 {
    x + y // 这里省略了 return
}

如果使用 return，则需要加上分号：

fn add(x: i32, y: i32) -> i32 {
    return x + y; // 使用 return 时需要分号
}

省略 return 是 Rust 的一种惯用法。

在 Rust 中，区间有两种常用的表示方法：

1. 1..100：不包括上限，表示从 1 到 99。
2. 1..=100：包括上限，表示从 1 到 100。

使用 ..= 可以确保上限值被包含在循环中。

在 Rust 中，有几种常见的函数写法和概念：

普通函数

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

带返回值的函数

不使用 return 关键字：

fn add(x: i32, y: i32) -> i32 {
    x + y
}

带有可变参数的函数

使用 mut 关键字：

fn increment(x: &mut i32) {
    *x += 1;
}

函数重载（不支持）

Rust 不支持函数重载，但可以通过泛型或不同的参数结构实现类似功能。

泛型函数

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

闭包

闭包是可以捕获环境的匿名函数：

fn main() {
    let add_one = |x: i32| x + 1;
    println!("{}", add_one(5));
}

方法

在结构体上定义方法：

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

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

关联函数

类似于静态方法：

impl Rectangle {
    fn new(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }
}

这些是 Rust 中一些常用的函数写法和概念。希望对你有帮助！