Rust(1)基础语法

Rust 是一种系统编程语言，以其高效性和内存安全性而闻名。它的语法相较于其他编程语言独特且简洁。本文将介绍 Rust 的基础语法，并给出代码示例。

1. 基本数据类型

Rust 提供了多种数据类型，主要可以分为标量和复合类型。

• 标量类型：
• 整型 (i32, u32, i64, f32, f64)
• 布尔型 (bool)

• 字符型 (char)

• 复合类型：

• 元组 (tuple)
• 数组 (array)

以下是标量类型和复合类型的示例：

fn main() {
    // 整型
    let a: i32 = 10;
    let b: f64 = 3.14;
    let c: bool = true;
    let d: char = 'R';

    // 元组
    let tuple: (i32, f64, char) = (10, 3.14, 'R');
    println!("Tuple: {:?}, Element 0: {}", tuple, tuple.0);

    // 数组
    let array: [i32; 3] = [1, 2, 3];
    println!("Array: {:?}", array);
}

2. 控制流

Rust 的控制流包括条件语句和循环。

• 条件语句使用 if 和 else：

fn main() {
    let number = 10;

    if number < 5 {
        println!("Number is less than 5");
    } else if number < 15 {
        println!("Number is between 5 and 15");
    } else {
        println!("Number is 15 or more");
    }
}

• 循环使用 loop、while 和 for：

fn main() {
    // loop示例
    let mut count = 0;
    loop {
        count += 1;
        if count == 5 {
            break; // 结束循环
        }
    }
    println!("Loop exited after {} iterations", count);

    // while示例
    let mut i = 0;
    while i < 5 {
        println!("i = {}", i);
        i += 1;
    }

    // for示例
    for j in 0..5 {
        println!("j = {}", j);
    }
}

3. 函数

Rust 中的函数使用 fn 关键字定义，并且支持返回值。函数的参数和返回值都需要明确声明类型。

fn main() {
    let result = add(5, 3);
    println!("5 + 3 = {}", result);

    let message = greet("Rust");
    println!("{}", message);
}

fn add(x: i32, y: i32) -> i32 {
    x + y // 直接返回
}

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

4. 所有权与借用

Rust 最大的特点之一就是它的所有权系统。所有权确保了内存安全，避免了内存泄漏和数据竞争。

fn main() {
    let s1 = String::from("Hello");
    let len = calculate_length(&s1); // 借用s1的引用
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len() // 使用引用来访问数据，不会转移所有权
}

5. 结构体

结构体用于创建自定义数据类型，将相关数据组合在一起。

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

fn main() {
    let rect = Rectangle { width: 30, height: 50 };
    println!("The area of the rectangle is {} square pixels.", area(&rect));
}

fn area(rect: &Rectangle) -> u32 {
    rect.width * rect.height
}

6. 模块和包

Rust 支持模块化编程，可以将相关的功能组织在一起。模块使用 mod 关键字定义。

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

fn main() {
    let result = math::add(10, 20);
    println!("10 + 20 = {}", result);
}

结论

Rust 的语法简洁明了，适合编写高效且安全的程序。通过以上示例，我们了解了 Rust 的基本数据类型、控制流、函数、所有权、结构体，以及模块组织。随着对 Rust 的深入学习，开发者可以更好地利用其特性，开发出高性能的应用程序。