Rust 程式設計入門與進階實務

– 12 分鐘閱讀

Rust 作為一門兼具效能與安全的現代系統程式語言，其學習曲線對 C++ 程式設計師來說相對平緩。本文將從 C++ 開發者的角度出發，逐步解析 Rust 的核心特性，包含所有權與借用機制、生命週期、錯誤處理、平行與網路程式設計、與 C/C++ 互動的 FFI，以及跨平臺桌面應用開發框架 Tauri 的應用。藉由豐富的程式碼範例，讀者能快速掌握 Rust 的開發精髓，並將其應用於實際專案中。

Rust 基礎

Rust 的基礎包括變數、資料型別、控制結構、函式和結構。Rust 的 ownership 模型和 borrow checker 是其最重要的特點之一，能夠確保記憶體安全和避免資料競爭。

物件導向程式設計

Rust 的物件導向程式設計是透過實作和特性來實作的。實作允許開發者在結構和列舉上定義方法和特性，從而實作物件導向程式設計的概念，如繼承和多型。

錯誤處理

Rust 的錯誤處理機制是根據型別系統的，使用 Result 和 Option 型別來表示可能的錯誤。開發者可以使用 try! 和 ? 運算子來簡化錯誤處理。

命令列介面應用程式

Rust 的命令列介面應用程式可以使用 structopts 函式函式庫來建立。開發者可以使用此函式函式庫來定義命令列選項和引數，並且可以使用 tokio 函式函式庫來建立非同步應用程式。

平行程式設計

Rust 的平行程式設計是根據執行緒和智慧指標的。開發者可以使用 std::thread 模組來建立執行緒，並且可以使用 std::sync 模組來同步執行緒。

網路程式設計

Rust 的網路程式設計可以使用 std::net 模組來建立同步和非同步的網路應用程式。開發者可以使用 tokio 函式函式庫來建立非同步網路應用程式。

桌面應用程式

Rust 的桌面應用程式可以使用 gtk 函式函式庫來建立。開發者可以使用此函式函式庫來建立原生的 Linux 桌面應用程式，並且可以使用 tauri 函式函式庫來建立跨平臺的桌面應用程式。

以下是 Rust 的一些基本程式碼範例：

// 變數和資料型別
let x: i32 = 10;
let y: f64 = 20.5;

// 控制結構
if x > 5 {
    println!("x 大於 5");
} else {
    println!("x 小於或等於 5");
}

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

// 結構
struct Person {
    name: String,
    age: i32,
}

// 實作
impl Person {
    fn new(name: String, age: i32) -> Person {
        Person { name, age }
    }
}

// 錯誤處理
fn divide(x: i32, y: i32) -> Result<i32, String> {
    if y == 0 {
        Err("除以零".to_string())
    } else {
        Ok(x / y)
    }
}

// 命令列介面應用程式
use structopt::StructOpt;

#[derive(StructOpt)]
struct Cli {
    #[structopt(short = "n", long = "name")]
    name: String,
}

fn main() {
    let cli = Cli::from_args();
    println!("Hello, {}!", cli.name);
}

// 平行程式設計
use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from another thread!");
    });
    handle.join().unwrap();
}

// 網路程式設計
use std::net::TcpListener;

fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
    for stream in listener.incoming() {
        match stream {
            Ok(mut stream) => {
                println!("Connection established!");
                // 處理網路請求
            }
            Err(e) => {
                println!("Error: {}", e);
            }
        }
    }
}

// 桌面應用程式
use gtk::prelude::*;

fn main() {
    // 初始化 GTK
    gtk::prelude::init();

    // 建立視窗
    let window = gtk::Window::new(gtk::WindowType::Toplevel);
    window.set_title("Hello, World!");
    window.set_default_size(350, 70);

    // 建立按鈕
    let button = gtk::Button::new_with_label("Click me!");
    button.connect_clicked(|_| {
        println!("Button clicked!");
    });

    // 將按鈕新增到視窗
    window.add(&button);

    // 顯示視窗
    window.show_all();

    // 主迴圈
    gtk::main();
}

這些程式碼範例展示了 Rust 的基礎語法和一些高階特性，如平行程式設計和網路程式設計。Rust 是一種強大的程式設計語言，能夠用於開發各種應用程式，從命令列工具到桌面應用程式和網路服務。

Rust 的不安全特性和外語言整合

Rust 的不安全特性（unsafe Rust）是一種允許開發者繞過 Rust 嚴格的記憶體安全機制，直接存取記憶體和執行不安全操作的功能。這種功能通常用於與其他語言（如 C/C++）進行整合，或者是在需要極高效能的應用中。

不安全操作的必要性

在某些情況下，開發者可能需要執行不安全操作，例如當需要直接存取硬體資源或執行低階別的系統呼叫時。然而，使用不安全操作需要非常小心，因為它可能導致記憶體安全問題和其他錯誤。

Rust FFI

Rust 的外語言介面（FFI）允許開發者在 Rust 程式中呼叫 C/C++ 函式，或者在 C/C++ 程式中呼叫 Rust 函式。這種功能使得開發者可以重用現有的 C/C++ 程式碼，或者在 Rust 程式中使用 C/C++ 函式函式庫。

程式碼生成和元程式設計

Rust 的元程式設計功能允許開發者在編譯時生成程式碼。這種功能可以用於自動生成重複的程式碼，或者在編譯時執行複雜的計算。

跨平臺桌面應用

Tauri 是一個跨平臺桌面應用框架，允許開發者使用 Rust 和其他語言（如 JavaScript）開發桌面應用。這種框架提供了一個簡單的方式來開發跨平臺的桌面應用。

結合 C 和 Rust

在某些情況下，開發者可能需要在 C 程式中呼叫 Rust 函式，或者在 Rust 程式中呼叫 C 函式。這種功能可以使用 Rust 的 FFI 來實作。

// 定義一個 C 函式
extern "C" {
    fn add(a: i32, b: i32) -> i32;
}

// 呼叫 C 函式
fn main() {
    let result = unsafe { add(2, 3) };
    println!("Result: {}", result);
}

// 定義一個 Rust 函式
extern "Rust" {
    fn multiply(a: i32, b: i32) -> i32;
}

// 呼叫 Rust 函式
int main() {
    int result = multiply(2, 3);
    printf("Result: %d\n", result);
    return 0;
}

所有權和可變性

在 Rust 中，所有權（Ownership）是一個非常重要的概念。它決定了誰負責管理某個值的記憶體空間。可變性（Mutability）則是指值是否可以被修改。

// 不可變的變數
let x = 5;
// 可變的變數
let mut y = 5;

猜數遊戲

下面是一個簡單的猜數遊戲，展示了 Rust 的基本語法：

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("猜數遊戲！");
    let secret_number = rand::thread_rng().gen_range(1..101);
    loop {
        println!("請輸入你的猜測（1-100）：");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("無法讀取輸入");
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("無效輸入。請輸入數字！");
                continue;
            }
        };
        println!("你猜的數字是：{}", guess);
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("太小了！"),
            Ordering::Greater => println!("太大了！"),
            Ordering::Equal => {
                println!("恭喜！你猜對了！");
                break;
            }
        }
    }
}

控制流程

Rust 的控制流程包括條件判斷、迴圈等。

條件判斷

Rust 的條件判斷使用 if 和 else 關鍵字：

let x = 5;
if x > 5 {
    println!("x 大於 5");
} else {
    println!("x 小於或等於 5");
}

迴圈

Rust 的迴圈包括 while 和 loop 關鍵字：

let mut x = 0;
while x < 5 {
    println!("{}", x);
    x += 1;
}

Match 陳述式

Rust 的 match 陳述式可以用來處理多種情況：

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

Borrowing 和 Copy

Rust 的 Borrowing 和 Copy 是兩種不同的記憶體管理機制。

Borrowing

Borrowing 是指暫時使用某個值的記憶體空間，而不會取得其所有權：

let s = String::from("hello");
let len = calculate_length(&s);
println!("字串長度：{}", len);
fn calculate_length(s: &String) -> usize {
    s.len()
}

Copy

Copy 是指複製某個值的內容，而不會影響原來的值：

let x = 5;
let y = x;
println!("x：{}，y：{}", x, y);

指標型別

Rust 的指標型別包括參照（Reference）和原始指標（Raw Pointer）：

let x = 5;
let rx = &x; // 參考
let px = &x as *const i32; // 原始指標

邏輯運運算元

Rust 的邏輯運運算元包括 &&、|| 和 !：

let x = true;
let y = false;
println!("{}", x && y); // false
println!("{}", x || y); // true
println!("{}", !x); // false

條件運運算元

Rust 的條件運運算元包括 if 和 match：

let x = 5;
if x > 5 {
    println!("x 大於 5");
} else {
    println!("x 小於或等於 5");
}

迴圈控制

Rust 的迴圈控制包括 while、loop 和 for：

let mut x = 0;
while x < 5 {
    println!("{}", x);
    x += 1;
}

以上內容簡要介紹了 Rust 的基礎知識，包括所有權、可變性、控制流程、Borrowing、Copy、指標型別、邏輯運運算元等。這些知識是 Rust 程式設計的基本，對於進一步學習 Rust 至關重要。

結構化程式設計

在程式設計中，結構化是指使用特定的語法和結構來組織和表達程式邏輯。這種方法可以使程式更容易閱讀、維護和擴充套件。

迴圈（For Loops）

迴圈是一種基本的程式結構，允許程式重複執行特定的程式碼區塊。例如，以下是 Rust 中的迴圈範例：

// 迴圈範例
let numbers = [1, 2, 3, 4, 5];
for number in numbers {
    println!("{}", number);
}

這段程式碼會輸出數字 1 到 5。

迴圈陳述式（Loop Statements）

迴圈陳述式是指用於控制迴圈執行的陳述式，例如 break 和 continue。以下是 Rust 中的迴圈陳述式範例：

// 迴圈陳述式範例
let mut i = 0;
loop {
    if i >= 5 {
        break;
    }
    println!("{}", i);
    i += 1;
}

這段程式碼會輸出數字 0 到 4。

函式（Functions）

函式是一種封裝程式邏輯的單元，允許程式重複使用特定的程式碼區塊。以下是 Rust 中的函式範例：

// 函式範例
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
}

這段程式碼會輸出 “Hello, Alice!"。

宣告函式（Declaring functions）

在 Rust 中，函式可以使用 fn 關鍵字宣告。以下是宣告函式的範例：

// 宣告函式範例
fn add(a: i32, b: i32) -> i32 {
    a + b
}

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

這段程式碼會輸出 5。

模組和公開性（Modules and publicity）

在 Rust 中，模組可以用於組織和封裝程式邏輯。以下是宣告模組的範例：

// 宣告模組範例
mod my_module {
    pub fn greet(name: &str) {
        println!("Hello, {}!", name);
    }
}

fn main() {
    my_module::greet("Alice");
}

這段程式碼會輸出 “Hello, Alice!"。

Super versus self

在 Rust 中，super 和 self 是兩個不同的關鍵字。super 用於存取父模組的成員，而 self 用於存取目前模組的成員。以下是範例：

// Super versus self 範例
mod my_module {
    pub fn greet(name: &str) {
        println!("Hello, {}!", name);
    }
}

fn main() {
    my_module::greet("Alice");
    // 使用 super 存取父模組的成員
    super::my_module::greet("Bob");
}

這段程式碼會輸出 “Hello, Alice!” 和 “Hello, Bob!"。

測試和效能評估（Testing and benchmarking）

在 Rust 中，測試和效能評估可以使用 #[test] 和 #[bench] 屬性進行。以下是範例：

// 測試範例
#[test]
fn add_test() {
    assert_eq!(2 + 2, 4);
}

// 效能評估範例
#[bench]
fn add_bench(b: &mut Bencher) {
    b.iter(|| 2 + 2);
}

這段程式碼會執行測試和效能評估。

Structs 和 Enums

在 Rust 中，struct 和 enum 是兩種基本的資料結構。以下是範例：

// Struct 範例
struct Person {
    name: String,
    age: u32,
}

// Enum 範例
enum Color {
    Red,
    Green,
    Blue,
}

這段程式碼會定義一個 Person struct 和一個 Color enum。

結構（Structures）

在 Rust 中，struct 可以用於定義複合資料結構。以下是範例：

// 結構範例
struct Point {
    x: f64,
    y: f64,
}

fn main() {
    let point = Point { x: 1.0, y: 2.0 };
    println!("x: {}, y: {}", point.x, point.y);
}

這段程式碼會輸出 “x: 1.0, y: 2.0”。

傳統 C Struct

在 Rust 中，struct 也可以用於定義傳統 C Struct。以下是範例：

// 傳統 C Struct 範例
#[repr(C)]
struct Person {
    name: *const u8,
    age: u32,
}

fn main() {
    let person = Person {
        name: b"John\0".as_ptr(),
        age: 30,
    };
    println!("name: {}, age: {}", person.name, person.age);
}

這段程式碼會輸出 “name: John, age: 30”。

Tuple Struct

在 Rust 中，struct 也可以用於定義 Tuple Struct。以下是範例：

// Tuple Struct 範例
struct Point(f64, f64);

fn main() {
    let point = Point(1.0, 2.0);
    println!("x: {}, y: {}", point.0, point.1);
}

這段程式碼會輸出 “x: 1.0, y: 2.0”。

空結構（Empty Struct）

在 Rust 中，struct 也可以用於定義空結構。以下是範例：

// 空結構範例
struct Unit;

fn main() {
    let unit = Unit;
    println!("unit: {:?}", unit);
}

這段程式碼會輸出 “unit: Unit”。

列舉（Enumerations）

在 Rust 中，enum 可以用於定義列舉。以下是範例：

// 列舉範例
enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let color = Color::Red;
    println!("color: {:?}", color);
}

這段程式碼會輸出 “color: Red”。

關鍵事實

  • Rust 是一種系統程式設計語言。
  • Rust 的基本語法包括迴圈、函式、模組、結構和列舉。
  • Rust 的資料結構包括 struct 和 enum。
  • Rust 的 struct 可以用於定義複合資料結構。
  • Rust 的 enum 可以用於定義列舉。

物件導向程式設計在結構和列舉中的應用

簡介

物件導向程式設計（OOP）是一種軟體設計方法，強調模組化、重用性和抽象化。雖然Rust是一種系統程式設計語言，但它也支援OOP的概念，特別是在結構（structs）和列舉（enums）中。

結構

在Rust中，結構是一種用於定義自定義資料型別的方式。它們可以包含多個欄位，每個欄位都有自己的名稱和資料型別。結構也可以實作特徵（traits），以提供額外的行為。

目標

在本章中，我們將探討如何在Rust的結構和列舉中應用OOP的概念。具體目標包括：

  • 從類別到結構：瞭解如何將類別的概念轉換為Rust的結構。
  • 實作特徵：學習如何使用特徵為結構新增行為。
  • 衍生特徵：瞭解如何使用衍生特徵為結構新增預設行為。
  • 型別別名：學習如何使用型別別名簡化資料型別的名稱。
  • 從範本到泛型：瞭解如何將範本的概念轉換為Rust的泛型。
  • 泛型結構：學習如何定義泛型結構。
  • 泛型特徵：瞭解如何定義泛型特徵。

從類別到結構

在物件導向程式設計中，類別是一種用於定義自定義資料型別的方式。在Rust中，結構扮演著類似的角色。以下是一個簡單的類別範例：

// 類別範例
class Person {
    private name: string;
    private age: number;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    public greet() {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}

在Rust中，我們可以使用結構和實作特徵來實作類似的行為：

// 結構範例
struct Person {
    name: String,
    age: u32,
}

impl Person {
    fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }

    fn greet(&self) {
        println!("Hello, my name is {} and I am {} years old.", self.name, self.age);
    }
}

實作特徵

特徵是Rust中的一種用於定義分享行為的方式。它們可以被實作為結構和列舉。以下是一個簡單的特徵範例：

// 特徵範例
trait Printable {
    fn print(&self);
}

impl Printable for Person {
    fn print(&self) {
        println!("Name: {}, Age: {}", self.name, self.age);
    }
}

衍生特徵

衍生特徵是Rust中的一種用於自動為結構和列舉新增預設行為的方式。以下是一個簡單的衍生特徵範例：

// 衍生特徵範例
#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
}

型別別名

型別別名是Rust中的一種用於簡化資料型別名稱的方式。以下是一個簡單的型別別名範例：

// 型別別名範例
type PersonRef = &Person;

從範本到泛型

範本是C++中的一種用於定義泛型行為的方式。在Rust中，泛型扮演著類似的角色。以下是一個簡單的範本範例：

// 範本範例
template <typename T>
class Container {
    private:
        T value;

    public:
        Container(T value) : value(value) {}

        T get() {
            return value;
        }
};

在Rust中，我們可以使用泛型來實作類似的行為：

// 泛型範例
struct Container<T> {
    value: T,
}

impl<T> Container<T> {
    fn new(value: T) -> Container<T> {
        Container { value }
    }

    fn get(&self) -> &T {
        &self.value
    }
}

泛型結構

泛型結構是Rust中的一種用於定義泛型資料型別的方式。以下是一個簡單的泛型結構範例：

// 泛型結構範例
struct Container<T> {
    value: T,
}

泛型特徵

泛型特徵是Rust中的一種用於定義泛型行為的方式。以下是一個簡單的泛型特徵範例：

// 泛型特徵範例
trait Printable<T> {
    fn print(&self, value: T);
}

impl<T> Printable<T> for Container<T> {
    fn print(&self, value: T) {
        println!("Value: {:?}", value);
    }
}

錯誤處理的重要性

錯誤處理是程式設計中的一個關鍵方面，能夠讓我們的程式更加穩健和可靠。在本章中，我們將探討C、C++和Rust三種語言中的錯誤處理機制，包括Option和Result型別的使用。

從技術架構視角來看，Rust 的所有權系統和借用檢查器雖然提升了記憶體安全和平行性，但也增加了學習曲線和程式碼複雜度。本文涵蓋了從基礎語法到高階特性的廣泛內容，包括物件導向程式設計、錯誤處理、平行程式設計以及與其他語言的整合，展現了 Rust 作為一門系統程式語言的多功能性。然而，要完全掌握 Rust 的精髓，開發者需要深入理解其所有權系統和生命週期管理，才能有效避免編譯錯誤並發揮其效能優勢。玄貓認為，Rust 適合追求極致效能和記憶體安全的系統級開發，但對於應用程式開發，需仔細評估其學習成本和開發效率。未來，隨著更多函式函式庫和工具的完善，Rust 的應用範圍有望進一步擴大，尤其在嵌入式系統、WebAssembly 和區塊鏈等領域。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。