在 Rust 中，宏（Macro）系统是实现编译期元编程（Metaprogramming）的关键机制。
不同于传统语言的宏替换，Rust 的宏是**语法级别（syntax-level）**的，它能生成合法的抽象语法树（AST），在编译阶段直接扩展代码。

Rust 的宏系统既是语言扩展的利器，也是**实现高性能与低样板代码（boilerplate）**的重要途径。
本篇将深入讲解宏的种类、设计理念与实际应用，帮助你全面掌握这一强大工具。

一、为什么需要宏

Rust 是一门强类型、零成本抽象的语言，但严格的类型系统有时会导致重复代码。例如：

fn print_i32(x: i32) {
    println!("值：{}", x);
}

fn print_f64(x: f64) {
    println!("值：{}", x);
}

若想支持多种类型，就需要重复定义多次。
而使用宏，我们可以在编译期生成对应的函数，从而消除重复逻辑、提升代码可维护性。

二、宏的分类

Rust 的宏主要分为三类：

1. 声明式宏（Declarative Macros）

   • 使用 macro_rules! 定义。

   • 最常用，基于模式匹配和代码展开。

2. 过程宏（Procedural Macros）

   • 类似函数，在编译期接收并生成代码。

   • 包括三种子类型：

     • 函数宏（Function-like Macros）

     • 派生宏（Derive Macros）

     • 属性宏（Attribute Macros）

3. 内置宏（Built-in Macros）

   • 如 println!、vec!、cfg! 等，是标准库中内置实现的宏。

三、声明式宏：macro_rules!

声明式宏通过模式匹配捕获输入，然后替换成目标代码。

示例：定义一个打印宏

macro_rules! my_print {
    ($val:expr) => {
        println!("值为：{}", $val);
    };
}

fn main() {
    my_print!(42);
    my_print!("Hello Rust");
}

解析：

• $val:expr 表示匹配一个表达式；

• => 后的代码会被替换到调用点；

• 编译器在展开时会直接生成对应的 println! 调用。

四、匹配多个分支

宏可以通过多个匹配规则实现灵活的模式控制。

macro_rules! calc {
    ($a:expr, +, $b:expr) => {
        println!("{} + {} = {}", $a, $b, $a + $b);
    };
    ($a:expr, *, $b:expr) => {
        println!("{} * {} = {}", $a, $b, $a * $b);
    };
}

fn main() {
    calc!(3, +, 4);
    calc!(2, *, 5);
}

宏匹配分支的逻辑类似 match 表达式，Rust 会在编译期决定展开哪个规则。

五、重复与递归匹配

Rust 宏支持可变数量的参数，通过 $(...)* 实现。

macro_rules! sum {
    ( $( $x:expr ),* ) => {
        {
            let mut total = 0;
            $(
                total += $x;
            )*
            total
        }
    };
}

fn main() {
    println!("总和: {}", sum!(1, 2, 3, 4, 5));
}

原理：

• $(...)* 表示匹配 0 个或多个；

• 每次匹配会在展开阶段生成独立代码段；

• 编译器自动内联，性能等同于手写循环。

六、过程宏：编译期函数生成器

与 macro_rules! 不同，过程宏是以 编译期插件 的形式运行的。
它接收一个语法树（TokenStream），生成新的代码片段。

要创建过程宏，需要定义单独的 crate，类型为 proc-macro。

示例：自定义 Derive 宏

假设我们想为结构体自动实现一个打印 trait。

// my_macro/src/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn;

#[proc_macro_derive(PrintMe)]
pub fn print_me_derive(input: TokenStream) -> TokenStream {
    let ast = syn::parse(input).unwrap();
    impl_printme(&ast)
}

fn impl_printme(ast: &syn::DeriveInput) -> TokenStream {
    let name = &ast.ident;
    let gen = quote! {
        impl PrintMe for #name {
            fn print(&self) {
                println!("{:?}", self);
            }
        }
    };
    gen.into()
}

然后在主项目中使用：

use my_macro::PrintMe;

#[derive(Debug, PrintMe)]
struct User {
    name: String,
    age: u32,
}

fn main() {
    let u = User { name: "Alice".to_string(), age: 25 };
    u.print();
}

底层原理：

• syn 用于解析输入 TokenStream；

• quote! 用于生成新的 Rust 代码；

• 宏在编译期被展开为实际的 trait 实现。

七、属性宏与函数宏

属性宏 用于修饰函数或结构体，例如：

#[route("/hello")]
fn hello() {
    println!("Hello Route!");
}

函数宏 则更接近普通函数的调用方式：

my_macro!(参数);

八、常见应用场景

1. 代码生成：自动实现重复性接口（如 Debug, Serialize）。

2. 简化 DSL：如 sqlx!、serde_json! 实现嵌入式语法。

3. 条件编译：通过 cfg! 宏在编译时选择不同代码路径。

4. 框架层封装：Web 框架（如 actix-web, rocket）大量依赖属性宏实现路由映射。

九、宏的注意事项

• 1.宏展开调试

  使用命令：

cargo rustc -- -Zunpretty=expanded

• 2.避免滥用宏

        宏不参与类型检查，过度使用会降低可读性。
        若逻辑可通过 trait、泛型或函数实现，应优先使用这些手段。

• 3命名空间冲突
  宏的命名作用域不同于普通函数，导入时需注意 #[macro_use] 或 use 方式。

十、总结

Rust 的宏系统是一种安全且强大的编译期元编程机制。
与 C/C++ 的文本替换宏不同，Rust 宏直接操作语法树（AST），既保证了类型安全，又能实现复杂的代码生成。

掌握宏系统，意味着你能在 Rust 中构建更高层的抽象与框架：

• 用声明式宏简化模板代码；

• 用过程宏构建灵活的 DSL；

• 用属性宏封装复杂逻辑。