Rust 进阶教程

Rust 进阶教程

在基础教程中，我们已经了解了Rust的基本语法和核心概念。本文将进一步探讨Rust的进阶特性和应用，包括泛型、闭包、迭代器、异步编程、宏和unsafe代码等。

目录

1. 泛型
2. 闭包和迭代器
   • 闭包
   • 迭代器
3. 异步编程
4. 宏
5. Unsafe代码
6. FFI（外部函数接口）
7. 设计模式
8. 性能优化
9. 案例分析

泛型

泛型允许我们编写更通用和复用的代码。Rust中的泛型主要用于函数、结构体、枚举和方法。

泛型函数

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

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = largest(&char_list);
    println!("The largest char is {}", result);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

泛型结构体

struct Point<T> {
    x: T,
    y: T,
}

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

fn main() {
    let integer_point = Point::new(5, 10);
    let float_point = Point::new(1.0, 4.0);
    println!("Integer Point: ({}, {})", integer_point.x, integer_point.y);
    println!("Float Point: ({}, {})", float_point.x, float_point.y);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

闭包和迭代器

闭包

闭包是可以捕获其环境的匿名函数。Rust中的闭包可以存储在变量中，作为参数传递给函数等。

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

    let mut x = 5;
    let mut add_to_x = |y: i32| {
        x += y;
    };
    add_to_x(10);
    println!("x: {}", x);
}
1
2
3
4
5
6
7
8
9
10
11
12

迭代器

迭代器用于在集合上进行迭代操作。Rust中的迭代器具有惰性，即只有在需要时才会执行。

fn main() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();

    for val in v1_iter {
        println!("Got: {}", val);
    }

    let v2: Vec<i32> = v1.iter().map(|x| x + 1).collect();
    println!("Transformed vector: {:?}", v2);
}
1
2
3
4
5
6
7
8
9
10
11

异步编程

Rust通过async和await关键字支持异步编程，使得编写并发代码变得更加容易。

use tokio::time::{sleep, Duration};

async fn do_something() {
    println!("Doing something...");
    sleep(Duration::from_secs(2)).await;
    println!("Done!");
}

#[tokio::main]
async fn main() {
    let future1 = do_something();
    let future2 = do_something();
    tokio::join!(future1, future2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

宏

宏是用于生成代码的强大工具。Rust有两种主要的宏：声明宏（macro_rules!）和过程宏。

声明宏

macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
}

fn main() {
    say_hello!();
}
1
2
3
4
5
6
7
8
9

过程宏

过程宏通常用于自定义属性和派生。

use proc_macro::TokenStream;

#[proc_macro]
pub fn my_macro(input: TokenStream) -> TokenStream {
    let input_str = input.to_string();
    format!("fn generated_fn() {{ println!(\"{}\"); }}", input_str).parse().unwrap()
}
1
2
3
4
5
6
7

Unsafe代码

Rust默认是安全的，但有时需要进行低级操作，这时可以使用unsafe代码块。

fn main() {
    let mut num = 5;
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    unsafe {
        println!("r1: {}", *r1);
        println!("r2: {}", *r2);
    }
}
1
2
3
4
5
6
7
8
9
10

FFI（外部函数接口）

Rust可以与其他语言（如C）进行互操作，这通常通过FFI实现。

调用C代码

extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}
1
2
3
4
5
6
7
8
9

设计模式

Rust也支持常见的设计模式，如单例模式、观察者模式等。

单例模式

use std::sync::{Arc, Mutex};
use std::thread;

struct Singleton {
    value: i32,
}

impl Singleton {
    fn instance() -> Arc<Mutex<Self>> {
        static mut SINGLETON: Option<Arc<Mutex<Singleton>>> = None;
        unsafe {
            SINGLETON.get_or_insert_with(|| {
                Arc::new(Mutex::new(Singleton { value: 0 }))
            }).clone()
        }
    }
}

fn main() {
    let singleton = Singleton::instance();
    {
        let mut singleton = singleton.lock().unwrap();
        singleton.value = 42;
    }

    let singleton = Singleton::instance();
    println!("Singleton value: {}", singleton.lock().unwrap().value);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

性能优化

Rust的性能优化包括使用内联、减少内存分配和使用高效的数据结构等。

内联函数

#[inline]
fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let result = add(5, 10);
    println!("Result: {}", result);
}
1
2
3
4
5
6
7
8
9

使用高效的数据结构

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert("key1", 10);
    map.insert("key2", 20);

    println!("Value for 'key1': {}", map.get("key1").unwrap());
}
1
2
3
4
5
6
7
8
9

案例分析

通过一个简单的Web服务器项目来综合应用所学知识。

项目结构

simple_web_server
├── Cargo.toml
└── src
    ├── main.rs
    └── lib.rs
1
2
3
4
5

代码实现

Cargo.toml

[package]
name = "simple_web_server"
version = "0.1.0"
edition = "2018"

[dependencies]
tokio = { version = "1", features = ["full"] }
hyper = "0.14"
1
2
3
4
5
6
7
8

src/lib.rs

use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
use std::net::SocketAddr;

async fn handle_request(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from("Hello, World!")))
}

pub async fn run() {
    let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
    let make_svc = make_service_fn(|_conn| {
        async { Ok::<_, Infallible>(service_fn(handle_request)) }
    });

    let server = Server::bind(&addr).serve(make_svc);
    if let Err(e) = server.await {
        eprintln!("Server error: {}", e);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

src/main.rs

#[tokio::main]
async fn main() {
    simple_web_server::run().await;
}
1
2
3
4

运行项目

cargo run
1

访问 http://127.0.0.1:8080，您将看到“Hello, World!”的响应。

以上就是Rust的进阶教程，通过学习这些内容，您将能够更好地掌握Rust并开发出更复杂和高效的应用程序。