在系統程式設計中，跨語言整合是常見的需求。Rust 提供了 unsafe 關鍵字和外部函式介面（FFI）機制，讓開發者能安全地與其他語言（如 C）互動。unsafe 關鍵字允許開發者繞過 Rust 的部分安全檢查，直接操作記憶體，但需要謹慎使用，避免引入安全風險。FFI 則提供了一套標準的規範，讓 Rust 可以呼叫其他語言的函式，反之亦然。本文將詳細介紹 unsafe 關鍵字和 FFI 的使用，並提供 Rust 與 C 語言互相呼叫的例項。

簡介

Rust是一種強調安全性的程式語言，但在某些情況下，仍需要使用不安全的程式碼。這個章節將介紹如何使用不安全的Rust和外部函式介面（FFI）。

結構

本章節將涵蓋以下主題：

• 使用unsafe關鍵字
• 不安全函式
• 不安全特徵
• 在Rust中使用C
• 在C中使用Rust

目標

• 學習如何使用unsafe關鍵字
• 瞭解不安全函式和不安全特徵的使用
• 學習如何在Rust中使用C程式碼
• 學習如何在C中使用Rust程式碼

使用unsafe關鍵字

unsafe關鍵字用於標記不安全的程式碼區塊。在這些區塊中，Rust的安全性檢查將被停用。

unsafe {
    // 不安全的程式碼
}

內容解密：

在上面的程式碼中，unsafe關鍵字用於標記一個不安全的程式碼區塊。在這個區塊中，Rust的安全性檢查將被停用。

不安全函式

不安全函式是使用unsafe關鍵字標記的函式。這些函式可以包含不安全的程式碼。

unsafe fn unsafe_function() {
    // 不安全的程式碼
}

內容解密：

在上面的程式碼中，unsafe_function是一個不安全函式。這個函式可以包含不安全的程式碼。

不安全特徵

不安全特徵是使用unsafe關鍵字標記的特徵。這些特徵可以包含不安全的程式碼。

unsafe trait UnsafeTrait {
    // 不安全的程式碼
}

內容解密：

在上面的程式碼中，UnsafeTrait是一個不安全特徵。這個特徵可以包含不安全的程式碼。

在Rust中使用C

Rust可以使用外部函式介面（FFI）來呼叫C程式碼。

extern "C" {
    fn c_function();
}

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

內容解密：

在上面的程式碼中，c_function是一個C函式。這個函式可以在Rust中使用extern "C"關鍵字來呼叫。

在C中使用Rust

Rust也可以使用外部函式介面（FFI）來呼叫C程式碼。

extern void rust_function();

int main() {
    rust_function();
    return 0;
}

內容解密：

在上面的程式碼中，rust_function是一個Rust函式。這個函式可以在C中使用extern關鍵字來呼叫。

圖表翻譯：

  flowchart TD
    A[使用unsafe關鍵字] --> B[不安全函式]
    B --> C[不安全特徵]
    C --> D[在Rust中使用C]
    D --> E[在C中使用Rust]
    E --> F[結論]

圖表翻譯：

在上面的流程圖中，展示了本章節的主要內容。從使用unsafe關鍵字開始，到不安全函式、不安全特徵、在Rust中使用C和在C中使用Rust，最後到結論。

超程式設計（Metaprogramming）技術

簡介

超程式設計是一種高階程式設計技術，允許開發者在編譯時或執行時生成、操控和轉換程式碼。這種技術在 Rust 中得到了廣泛的應用，特別是在建立 Domain-Specific Languages（DSL）和高效的程式碼生成方面。

結構

超程式設計的結構可以分為以下幾個部分：

• 宣告式巨集（Declarative Macros）
• 程式式巨集（Procedural Macros）
• 衍生巨集（Derive Macros）
• 屬性巨集（Attribute Macros）
• 函式式巨集（Function-like Macros）

目標

在本章中，我們將探討超程式設計的基礎知識，包括何時建立巨集、如何建立宣告式巨集、程式式巨集、衍生巨集和屬性巨集等。

何時建立巨集？

巨集通常用於以下情況：

• 程式碼重複：當你需要重複使用某段程式碼時，巨集可以幫助你自動生成這些程式碼。
• 程式碼轉換：當你需要將某段程式碼轉換為另一種形式時，巨集可以幫助你完成這個過程。
• DSL：當你需要建立一個 Domain-Specific Language 時，巨集可以幫助你定義這個語言的語法和語義。

宣告式巨集

宣告式巨集是 Rust 中的一種巨集，它允許你使用宣告式語法定義巨集。宣告式巨集的語法如下：

macro_rules! macro_name {
    (pattern) => {
        expansion
    };
}

建立宣告式巨集

以下是建立一個簡單的宣告式巨集的例子：

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

fn main() {
    say_hello!();
}

重複

宣告式巨集也可以用於重複程式碼。以下是使用宣告式巨集重複程式碼的例子：

macro_rules! repeat {
    ($($body:tt)*) => {
        $($body)*
    };
}

fn main() {
    repeat! {
        println!("Hello!");
    }
}

程式式巨集

程式式巨集是 Rust 中的一種巨集，它允許你使用程式式語法定義巨集。程式式巨集的語法如下：

#[proc_macro]
pub fn macro_name(input: TokenStream) -> TokenStream {
    // ...
}

衍生巨集

衍生巨集是 Rust 中的一種巨集，它允許你自動為某個型別衍生特定的 trait。衍生巨集的語法如下：

#[derive(MacroName)]
struct TypeName {
    // ...
}

屬性巨集

屬性巨集是 Rust 中的一種巨集，它允許你為某個項新增特定的屬性。屬性巨集的語法如下：

#[attribute_name]
fn function_name() {
    // ...
}

函式式巨集

函式式巨集是 Rust 中的一種巨集，它允許你定義一個巨集，它的行為類似於函式。函式式巨集的語法如下：

macro_rules! macro_name {
    ($($arg:tt)*) => {
        // ...
    };
}

重點

• 超程式設計是一種高階程式設計技術。
• 宣告式巨集、程式式巨集、衍生巨集、屬性巨集和函式式巨集是 Rust 中的五種巨集。
• 巨集可以用於程式碼重複、程式碼轉換和 DSL。

練習

1. 建立一個簡單的宣告式巨集，列印 “Hello!"。
2. 建立一個程式式巨集，自動為某個型別衍生特定的 trait。
3. 建立一個屬性巨集，為某個項新增特定的屬性。
4. 建立一個函式式巨集，定義一個巨集，它的行為類似於函式。

Mufi 標準函式庫專案：探索 Mufi 語言的核心

導論

Mufi 是一種新興的程式語言，旨在提供簡潔高效的開發體驗。在這個專案中，我們將深入探索 Mufi 的標準函式庫（StdLib），並逐步介紹如何使用 Mufi 進行開發。

結構

本文將分為以下章節：

1. Mufi 語言入門：介紹 Mufi 的基本語法和特性。
2. 變數宣告：學習如何在 Mufi 中宣告和使用變數。
3. 控制流：探索 Mufi 的控制流程，包括條件判斷和迴圈。
4. 函式：瞭解如何定義和使用函式在 Mufi 中。
5. 類別：深入瞭解 Mufi 的類別和物件導向程式設計。
6. 繼承：學習如何使用繼承機制在 Mufi 中。
7. 使用 C 建立原生函式：探索如何使用 C 語言建立原生函式並整合到 Mufi 中。
8. 使用 Rust 建立原生函式：瞭解如何使用 Rust 語言建立原生函式並與 Mufi 整合。
9. C 與 Rust 原生函式的效能比較：比較使用 C 和 Rust 建立的原生函式在 Mufi 中的效能差異。
10. 結論：總結本文的主要內容和心得。

Mufi 入門

Mufi 是一種設計用於高效率和簡潔的語言，讓開發者能夠快速地建立應用程式。它的語法簡單易學，同時也提供了豐富的功能和特性。

宣告變數

在 Mufi 中，宣告變數使用 let 關鍵字。例如：

let x = 5;

這行程式碼宣告了一個名為 x 的變數，並將其初始化為 5。

控制流

Mufi 支援多種控制流程，包括 if 判斷和 loop 迴圈。例如：

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

這段程式碼使用 if 判斷來檢查 x 的值，並根據結果執行不同的程式碼。

迴圈

Mufi 的迴圈可以使用 loop 關鍵字。例如：

let mut i = 0;
loop {
    println!("{}", i);
    i += 1;
    if i >= 10 {
        break;
    }
}

這段程式碼使用 loop 迴圈來印出 0 到 9 的數字。

函式

Mufi 的函式可以使用 fn 關鍵字定義。例如：

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

這個函式定義了一個名為 add 的函式，接受兩個 i32 型別的引數，並傳回一個 i32 型別的結果。

類別

Mufi 的類別可以使用 struct 關鍵字定義。例如：

struct Person {
    name: String,
    age: u32,
}

這個類別定義了一個名為 Person 的結構體，包含兩個欄位：name 和 age。

繼承

Mufi 的繼承可以使用 impl 關鍵字實作。例如：

struct Animal {
    name: String,
}

struct Dog {
    name: String,
    breed: String,
}

impl Animal for Dog {
    fn sound(&self) {
        println!("汪汪！");
    }
}

這個例子定義了一個 Animal 類別和一個 Dog 類別，Dog 類別繼承自 Animal 類別，並實作了 sound 方法。

使用 C 建立原生函式

Mufi 支援使用 C 語言建立原生函式。例如：

#include <stdio.h>

void hello_from_c() {
    printf("Hello from C!\n");
}

這個 C 函式可以在 Mufi 中使用：

extern "C" {
    fn hello_from_c();
}

fn main() {
    hello_from_c();
}

使用 Rust 建立原生函式

Mufi 也支援使用 Rust 語言建立原生函式。例如：

#[no_mangle]
pub extern "C" fn hello_from_rust() {
    println!("Hello from Rust!");
}

這個 Rust 函式可以在 Mufi 中使用：

extern "C" {
    fn hello_from_rust();
}

fn main() {
    hello_from_rust();
}

C 與 Rust 原生函式的效能比較

在 Mufi 中，C 和 Rust 原生函式的效能差異取決於具體的應用程式和硬體平臺。一般而言，Rust 的原生函式可能會因為其記憶體安全機制和編譯時期檢查而具有更好的效能。

Tauri 專案開發：打造跨平臺桌面應用

導言

Tauri 是一個相當有趣的框架，允許開發者使用 Web 技術（如 HTML、CSS 和 JavaScript）建立跨平臺的桌面應用。這意味著您可以使用熟悉的 Web 開發工具和語言，打造出在 Windows、macOS 和 Linux 上都能順暢執行的應用。

結構

一個典型的 Tauri 專案包含以下幾個主要部分：

• 前端: 使用 Web 技術（HTML、CSS、JavaScript）開發的使用者介面和邏輯。
• 後端: 使用 Rust 或其他語言開發的核心邏輯和系統互動。
• Tauri 核心: 負責管理前後端之間的溝通和系統資源的存取。

目標

在這個專案中，您將學習如何：

• 建立一個新的 Tauri 專案。
• 使用 Svelte 作為前端框架。
• 管理應用的生命週期和系統互動。
• 處理錯誤和異常。

環境準備

開始之前，請確保您的系統中已經安裝了以下必需的工具：

• Node.js
• npm 或 yarn
• Rust

Hello World in Tauri

建立一個新的 Tauri 專案可以使用以下命令：

npm create tauri-app

按照提示完成初始化過程後，您就可以看到一個基本的 Tauri 專案結構。

熟悉 Svelte

Svelte 是一個輕量級的前端框架，非常適合用於 Tauri 專案。它允許您使用簡單的語法建立回應式的 UI元件。

<script>
  let name = 'World';
</script>

<h1>Hello {name}!</h1>

應用概覽

在這個專案中，您將建立一個簡單的桌面應用，展示 Tauri 的基本功能，包括：

• 建立視窗和設定其屬性。
• 處理系統事件和使用者互動。
• 使用 Svelte 建立動態的 UI。

建立應用

使用 Tauri CLI 建立一個新的專案，並選擇 Svelte 作為前端框架。然後，開始編寫您的應用邏輯和 UI。

進一步探索 Tauri

Tauri 提供了許多強大的功能，包括：

• 系統整合: 存取系統資源，如檔案系統、網路等。
• 安全性: 透過 Rust 的記憶體安全機制，確保您的應用免受記憶體相關的安全威脅。
• 跨平臺: 在多個平臺上佈署您的應用，無需修改程式碼。

錯誤處理

在開發過程中，錯誤是不可避免的。Tauri 提供了強大的錯誤處理機制，允許您捕捉和處理異常。

use tauri::Error;

fn main() -> Result<(), Error> {
    // ...
}

內容解密：

以上程式碼展示瞭如何在 Tauri 中使用 Rust 來處理錯誤。透過使用 Result 型別和 Error trait，您可以輕鬆地捕捉和處理異常，確保您的應用更加穩健。

圖表翻譯：

  flowchart TD
    A[開始] --> B[建立 Tauri 專案]
    B --> C[初始化 Svelte]
    C --> D[編寫應用邏輯]
    D --> E[處理系統事件]
    E --> F[展示 UI]
    F --> G[錯誤處理]

此圖表展示了 Tauri 專案的基本流程，從建立專案到處理錯誤。每一步驟都對應到一個特定的任務，幫助您更好地理解 Tauri 的工作原理。

Rust程式設計入門

簡介

Rust是一種相對新興的程式設計語言，從設計之初就著重於記憶體安全和零抽象。與其他系統程式設計語言如C或C++相比，Rust提供了接近的效能同時避免了記憶體相關的問題，如記憶體洩漏、雙重釋放或段錯誤。這是如何實作的呢？我們稍後會在本章中詳細探討，但簡單來說，Rust使用繫結（binding）的生命週期（lifetime）和所有權（ownership）來管理記憶體。在編譯器中，有一個叫做借用檢查器（borrow checker）的東西，它的角色是為每個繫結檢查所有權，並在超出範圍時將其丟棄。所有權在這裡意味著每個繫結或變數擁有其值，而當另一個繫結取走這個值時，之前的繫結就會被丟棄。

如果這些概念看起來令人不知所措，不要擔心；我們將一起學習如何與借用檢查器合作，並學會如何愛它。編譯器教我們如何成為更聰明的程式設計師，因此在記憶體管理方面做出更安全的決定。本章假設您已經有一定的C++知識。我們將在書中某些地方比較Rust和C++的程式碼，希望這能夠幫助您更容易地學習Rust。

結構

在本章中，我們將討論以下主題：

• 安裝Rust
• Cargo入門
• 繫結和可變性

安裝Rust

要開始使用Rust，您需要在您的系統上安裝Rust。您可以從Rust官網下載並安裝Rust。安裝過程相對簡單，按照提示即可完成。

Cargo入門

Cargo是Rust的套件管理器和建構系統。它可以幫助您管理依賴項、建構和測試您的程式。要使用Cargo，您需要建立一個新的Cargo專案。您可以使用以下命令建立一個新的Cargo專案：

cargo new myproject

這將建立一個新的目錄叫做myproject，其中包含了一個基本的Cargo專案結構。

繫結和可變性

在Rust中，繫結是指變數和其值之間的關係。繫結可以是可變的，也可以是不可變的。可變的繫結可以被修改，而不可變的繫結不能被修改。

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

在上面的例子中，x是不可變的繫結，而y是可變的繫結。

內容解密：

在Rust中，繫結和可變性是兩個非常重要的概念。繫結是指變數和其值之間的關係，而可變性則是指繫結是否可以被修改。瞭解這兩個概念是學習Rust的關鍵。

圖表翻譯：

  graph LR
    A[繫結] -->|不可變|> B[不可變的繫結]
    A -->|可變|> C[可變的繫結]
    B -->|不能被修改|> D[記憶體安全]
    C -->|可以被修改|> E[記憶體不安全]

在上面的圖表中，我們可以看到繫結和可變性之間的關係。繫結可以是不可變的，也可以是可變的。不可變的繫結不能被修改，而可變的繫結可以被修改。這兩個概念是Rust記憶體安全性的基礎。

Rust 入門： Ownership 和控制流

Rust是一種強大的程式語言，提供了 Ownership 和 Borrowing 的概念，以確保記憶體安全和效率。Ownership 是 Rust 中的一個基本概念，指的是每個值都有一個所有者，這個所有者負責管理值的生命週期。

Ownership 的基本規則

1. 每個值都有一個所有者。
2. 每個值只能有一個所有者。
3. 當所有者離開作用域時，值會被丟棄。

控制流

Rust 的控制流包括 If/Else 陳述式、Match 陳述式、迴圈等。

If/Else 陳述式

If/Else 陳述式用於根據條件執行不同的程式碼。

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

Match 陳述式

Match 陳述式用於根據值的模式執行不同的程式碼。

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

迴圈

Rust 的迴圈包括 While 迴圈、For 迴圈和 Loop 迴圈。

While 迴圈

While 迴圈用於根據條件重複執行程式碼。

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

For 迴圈

For 迴圈用於遍歷集合中的元素。

let fruits = ["apple", "banana", "cherry"];
for fruit in fruits {
    println!("fruit 等於 {}", fruit);
}

Loop 迴圈

Loop 迴圈用於無限重複執行程式碼。

loop {
    println!("無限迴圈");
}

函式

Rust 的函式用於封裝程式碼，方便重複使用。

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

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

Struct 和 Enum

Rust 的 Struct 和 Enum 用於定義自訂資料型別。

Struct

Struct 用於定義複合資料型別。

struct Person {
    name: String,
    age: u32,
}

fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 30,
    };
    println!("name: {}, age: {}", person.name, person.age);
}

Enum

Enum 用於定義列舉型別。

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let color = Color::Green;
    match color {
        Color::Red => println!("紅色"),
        Color::Green => println!("綠色"),
        Color::Blue => println!("藍色"),
    }
}

Cargo

Cargo 是 Rust 的套件管理器，提供了建立和管理 Rust 專案的功能。

cargo new myproject
cd myproject
cargo build
cargo run

安裝 Rust

要安裝 Rust，可以使用 rustup 工具。

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Rust 基礎知識：二進位制和函式函式庫專案

Rust 的 Cargo 包管理器可以建立兩種型別的專案：二進位制專案和函式函式庫專案。二進位制專案會建立一個可執行檔，並包含一個 main.rs 檔案；而函式函式庫專案則是一個可以在不同專案中使用的程式碼集合，包含一個 lib.rs 檔案。

在這個例子中，我們將建立一個二進位制專案。可以使用以下命令建立一個新的 Cargo 專案：

cargo new bindings_and_mut --bin

這將會建立一個新的目錄 bindings_and_mut，其中包含以下結構：

bindings_and_mut/
Cargo.lock
Cargo.toml
src/
main.rs

讓我們看看每個檔案的作用：

• Cargo.lock：儲存專案的依賴關係快取。
• Cargo.toml：包含專案的所有後設資料和依賴關係。
• src/：包含專案的所有原始碼。如果是二進位制專案，則包含一個 main.rs 檔案；如果是函式函式庫專案，則包含一個 lib.rs 檔案。

現在，讓我們編輯 Cargo.toml 檔案，以新增 rand 函式函式庫，然後建立一個猜數遊戲：

[package]
name = "bindings_and_mut"
version = "0.1.0"
edition = "2021"

[dependencies]
rand = "0.8.5"

Rust 的繫結和可變性

讓我們首先看一個簡單的 C++ 程式，展示不同資料型別的變數：

int main(){
    auto varOne = 76; // 自動推斷整數
    char* varTwo = "var Two"; // C 字串
    int varThree = 69; // 整數
    double varFour = 42.0; // 浮點數數
    return 0;
}

現在，讓我們在 Rust 中建立相同的程式。首先，我們需要知道如何宣告繫結。可以使用 let 關鍵字宣告繫結。繫結的資料型別可以隱含推斷，也可以使用分隔符號 (:) 明確宣告。

讓我們重建程式：

fn main(){
    let varOne = 76; // 自動推斷整數
    let varTwo: &str = "var Two"; // 借用字串
    let varThree: i32 = 69; // 32 位整數
    let varFour: f64 = 42.0; // 64 位浮點數數
}

可能會對資料型別感到有些混淆，但這是正常的。以下是每個資料型別的說明：

內容解密：

在 Rust 中，使用 let 關鍵字宣告繫結，繫結的資料型別可以隱含推斷或明確宣告。可以使用分隔符號 (:) 明確宣告繫結的資料型別。

圖表翻譯：

  graph LR
    A[宣告繫結] --> B[使用 let 關鍵字]
    B --> C[隱含推斷資料型別]
    C --> D[明確宣告資料型別]
    D --> E[使用分隔符號 (:) ]
    E --> F[宣告繫結完成]

在這個圖表中，我們展示了在 Rust 中宣告繫結的過程。首先，使用 let 關鍵字宣告繫結，然後可以隱含推斷或明確宣告繫結的資料型別。最後，使用分隔符號 (:) 明確宣告繫結的資料型別。

資料型別描述

在電腦科學中，資料型別是指用於描述變數或表示式的型別。以下是 Rust 中的基本資料型別：

從底層實作到高階應用的全面檢視顯示，Rust 的安全性與效能並重的特性使其在系統程式設計、嵌入式開發以及 WebAssembly 等領域展現出獨特的優勢。透過多維度效能指標的實測分析，Rust 的零成本抽象和嚴格的編譯期檢查有效地避免了常見的記憶體安全問題，同時達到了與 C/C++ 相媲美的效能水準。儘管學習曲線較陡峭，但從長遠來看，Rust 的安全性及可靠性降低了維護成本和技術債務。對於追求極致效能和系統穩定的開發者而言，Rust 允許更精細地控制底層資源，同時也提供了現代化的開發體驗。玄貓認為，Rust 已展現足夠成熟度，適合關注效能和安全性的關鍵系統採用。