编译期代码生成:Rust 声明宏与过程宏的深度实战

解决【x2openEuler环境检查未通过——CheckRepoCurlActor不通过】问题 摘要:x2openEuler使用默认repo源时出现环境检查失败问题,原因是默认源返回308永久重定向错误。解决方法包括:1)为CentOS主机配置华为yum源;2)在x2openEuler Web界面修改为自定义可用源。具体步骤包括备份原源、下载华为源、清除缓存,并通过curl测试确认新源可用性。最终成功配置openEuler-24.03-LTS-SP1版本的repo源后,环境检查顺利通过。 阅读详情

编译期代码生成:Rust 声明宏与过程宏的深度实战

cover

一、重复代码的编译期消除:为什么需要宏

Rust 的泛型系统通过单态化(Monomorphization)在编译期生成特化代码,实现了零运行时开销的多态。但泛型只能抽象类型,无法抽象语法结构。当多个结构体需要相同的 trait 实现、相同的字段访问模式、相同的序列化逻辑时,泛型无能为力——这些重复代码的结构是相同的,但具体类型和字段名不同。

宏(Macro)是 Rust 提供的编译期代码生成机制。声明宏(macro_rules!)通过模式匹配和替换生成代码,过程宏(Procedural Macro)通过操作语法树(TokenStream)生成代码。两者的核心区别在于抽象层级:声明宏操作的是 token 序列,过程宏操作的是 AST 节点。理解宏的展开机制和卫生性(Hygiene),是避免生成错误代码和调试困难的关键。

二、声明宏的模式匹配与卫生性:token 级的代码生成

2.1 声明宏的展开机制

声明宏在编译的预处理阶段展开。编译器将宏调用处的 token 序列与宏定义中的模式进行匹配,匹配成功后用替换模板生成新的 token 序列。这个过程是纯文本替换——宏不检查类型、不解析语义,只做模式匹配。

graph LR
    subgraph 声明宏展开流程
        A[宏调用<br/>my_macro!(x, y)] --> B[Token 序列匹配]
        B -->|匹配成功| C[替换模板填充]
        C --> D[生成新 Token 序列]
        D --> E[继续编译]
    end

    subgraph 过程宏展开流程
        F[宏调用<br/>#[derive(MyTrait)]] --> G[解析为 TokenStream]
        G --> H[构建/修改 AST]
        H --> I[生成新 TokenStream]
        I --> E
    end

    subgraph 卫生性保证
        J[宏内定义的变量] -->|不同语法上下文| K[不会与外部变量冲突]
        L[宏内引用的外部变量] -->|路径解析| M[必须在宏调用处可见]
    end

2.2 声明宏的片段分类符

Rust 声明宏使用片段分类符(Fragment Specifier)约束匹配的语法结构:

分类符匹配内容示例
expr表达式1 + 2, foo()
ident标识符x, MyStruct
ty类型Vec<String>, &'a str
path路径std::collections::HashMap
block代码块{ let x = 1; }
item项fn foo() {}, struct Bar;
meta元属性derive(Debug), inline
tt单个 token 树任意 token 或 (...)/[...]/{...}

2.3 卫生性规则

声明宏的卫生性通过"语法上下文"(Syntax Context)实现。宏内定义的变量携带宏的语法上下文标记,与宏外部同名变量属于不同的命名空间。这防止了宏展开后意外捕获外部变量。但卫生性是单向的——宏内引用的外部变量必须在宏调用处可见,否则编译错误。

三、生产级宏的实现

3.1 声明宏:构建类型安全的构建器模式

/// 声明宏:自动生成 Builder 模式的实现
/// 消除为每个结构体手写 Builder 的重复代码
macro_rules! builder {
    (
        // 目标结构体名称
        $(#[$meta:meta])*
        $name:ident {
            $(
                // 字段定义:名称、类型、是否必填
                $(#[$field_meta:meta])*
                $field:ident : $ty:ty $(= $default:expr)?
            ),* $(,)?
        }
    ) => {
        // 生成原始结构体
        $(#[$meta])*
        pub struct $name {
            $(
                $(#[$field_meta])*
                pub $field: $ty,
            )*
        }

        // 生成 Builder 结构体
        // 必填字段使用 Option<T>,可选字段使用预填充的默认值
        paste::paste! {
            pub struct [<$name Builder>] {
                $(
                    $field: Option<$ty>,
                )*
            }

            impl [<$name Builder>] {
                // 为每个字段生成 setter 方法
                $(
                    pub fn $field(mut self, value: $ty) -> Self {
                        self.$field = Some(value);
                        self
                    }
                )*

                /// 构建最终结构体,检查所有必填字段
                pub fn build(self) -> Result<$name, BuilderError> {
                    $(
                        let $field = self.$field$(.or_else(|| Some($default)))?
                            .ok_or_else(|| BuilderError::MissingField(stringify!($field)))?;
                    )*

                    Ok($name {
                        $($field,)*
                    })
                }
            }

            impl $name {
                /// 创建 Builder 实例
                pub fn builder() -> [<$name Builder>] {
                    [<$name Builder>] {
                        $($field: None,)*
                    }
                }
            }
        }
    };
}

#[derive(Debug)]
pub enum BuilderError {
    MissingField(&'static str),
}

// 使用宏生成结构体和 Builder
builder! {
    #[derive(Debug)]
    ServerConfig {
        host: String,
        port: u16 = 8080,
        max_connections: usize = 100,
        timeout_secs: u64 = 30,
    }
}

// 使用示例
fn example_usage() -> Result<(), BuilderError> {
    let config = ServerConfig::builder()
        .host("127.0.0.1".to_string())
        .port(3000)
        .build()?;

    // host 是必填字段,缺少会返回错误
    let bad_config = ServerConfig::builder()
        .port(3000)
        .build(); // 返回 Err(MissingField("host"))

    Ok(())
}

3.2 派生过程宏:自动实现序列化 trait

// ============================================
// 过程宏 crate: my_derive
// Cargo.toml 中需要:
// [lib]
// proc-macro = true
// [dependencies]
// syn = "2"
// quote = "1"
// proc-macro2 = "1"
// ============================================

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Data, Fields, Field, Ident, Type};

/// 派生宏:自动实现 BinarySerialize trait
/// 将结构体按字段顺序序列化为二进制格式
#[proc_macro_derive(BinarySerialize)]
pub fn derive_binary_serialize(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    // 提取所有命名字段
    let fields = match &input.data {
        Data::Struct(data) => match &data.fields {
            Fields::Named(fields) => &fields.named,
            Fields::Unnamed(_) => {
                return syn::Error::new_spanned(
                    &input,
                    "BinarySerialize 仅支持命名字段结构体",
                )
                .to_compile_error()
                .into();
            }
            Fields::Unit => {
                return syn::Error::new_spanned(
                    &input,
                    "Unit 结构体无需序列化",
                )
                .to_compile_error()
                .into();
            }
        },
        _ => {
            return syn::Error::new_spanned(
                &input,
                "BinarySerialize 仅支持结构体",
            )
            .to_compile_error()
            .into();
        }
    };

    // 为每个字段生成序列化和反序列化代码
    let serialize_fields = fields.iter().map(|field| {
        let field_name = &field.ident;
        quote! {
            // 每个字段调用其 BinarySerialize 实现
            BinarySerialize::serialize(&self.#field_name, buf)?;
        }
    });

    let deserialize_fields = fields.iter().map(|field| {
        let field_name = &field.ident;
        let field_type = &field.ty;
        quote! {
            #field_name: <#field_type as BinarySerialize>::deserialize(buf)?,
        }
    });

    let field_names = fields.iter().map(|f| &f.ident);

    let expanded = quote! {
        impl BinarySerialize for #name {
            fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), SerializeError> {
                #(#serialize_fields)*
                Ok(())
            }

            fn deserialize(buf: &mut &[u8]) -> Result<Self, SerializeError> {
                Ok(Self {
                    #(#deserialize_fields)*
                })
            }
        }
    };

    TokenStream::from(expanded)
}

// ============================================
// 使用端:在业务 crate 中引用
// ============================================

/// BinarySerialize trait 定义
pub trait BinarySerialize: Sized {
    fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), SerializeError>;
    fn deserialize(buf: &mut &[u8]) -> Result<Self, SerializeError>;
}

#[derive(Debug)]
pub enum SerializeError {
    BufferOverflow,
    InvalidData(String),
}

// 为基础类型实现 trait
impl BinarySerialize for u32 {
    fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), SerializeError> {
        buf.extend_from_slice(&self.to_le_bytes());
        Ok(())
    }

    fn deserialize(buf: &mut &[u8]) -> Result<Self, SerializeError> {
        if buf.len() < 4 {
            return Err(SerializeError::BufferOverflow);
        }
        let bytes: [u8; 4] = buf[..4].try_into().map_err(|_| SerializeError::BufferOverflow)?;
        *buf = &buf[4..];
        Ok(u32::from_le_bytes(bytes))
    }
}

impl BinarySerialize for String {
    fn serialize(&self, buf: &mut Vec<u8>) -> Result<(), SerializeError> {
        let len = self.len() as u32;
        len.serialize(buf)?;
        buf.extend_from_slice(self.as_bytes());
        Ok(())
    }

    fn deserialize(buf: &mut &[u8]) -> Result<Self, SerializeError> {
        let len = u32::deserialize(buf)? as usize;
        if buf.len() < len {
            return Err(SerializeError::BufferOverflow);
        }
        let s = String::from_utf8(buf[..len].to_vec())
            .map_err(|e| SerializeError::InvalidData(e.to_string()))?;
        *buf = &buf[len..];
        Ok(s)
    }
}

// 使用派生宏
#[derive(BinarySerialize, Debug)]
struct Packet {
    id: u32,
    payload: String,
    checksum: u32,
}

3.3 属性过程宏:编译期参数校验

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn, LitInt, LitStr};

/// 属性宏:为函数添加参数范围校验
/// 用法:#[validate_args("id: 1..1000", "name: 1..256")]
#[proc_macro_attribute]
pub fn validate_args(attr: TokenStream, item: TokenStream) -> TokenStream {
    let func = parse_macro_input!(item as ItemFn);

    // 解析属性参数:字段名和范围
    let validations: Vec<(String, u64, u64)> = attr.to_string()
        .split(',')
        .filter_map(|s| {
            let s = s.trim().trim_matches('"');
            let parts: Vec<&str> = s.split(':').collect();
            if parts.len() == 2 {
                let name = parts[0].trim().to_string();
                let range: Vec<&str> = parts[1].trim().split("..").collect();
                if range.len() == 2 {
                    let min = range[0].parse().ok()?;
                    let max = range[1].parse().ok()?;
                    return Some((name, min, max));
                }
            }
            None
        })
        .collect();

    // 生成校验代码
    let checks = validations.iter().map(|(name, min, max)| {
        quote! {
            if #name < #min || #name > #max {
                return Err(ValidationError::OutOfRange {
                    field: stringify!(#name),
                    min: #min,
                    max: #max,
                    actual: #name,
                });
            }
        }
    });

    let func_name = &func.sig.ident;
    let func_block = &func.block;
    let func_inputs = &func.sig.inputs;
    let func_output = &func.sig.output;

    let expanded = quote! {
        fn #func_name(#func_inputs) #func_output {
            #(#checks)*
            #func_block
        }
    };

    TokenStream::from(expanded)
}

#[derive(Debug)]
pub enum ValidationError {
    OutOfRange {
        field: &'static str,
        min: u64,
        max: u64,
        actual: u64,
    },
}

四、宏的暗面:调试困难与编译时膨胀

宏的强大能力伴随着显著的工程风险,需要在设计时审慎评估。

调试困难。宏展开后的代码不出现在源文件中,当编译器报错时,错误行号指向的是展开后的代码,而非宏定义或宏调用处。cargo expand 可以查看展开结果,但在复杂的嵌套宏中,追踪错误的根源仍然耗时。过程宏的错误信息质量取决于宏作者是否使用了 syn::Error::new_spanned 提供精确的 span 信息。

编译时膨胀。宏在编译期生成代码,过度使用会导致编译产物体积膨胀和编译时间增长。一个典型的例子是 serde 的派生宏——为包含 50 个字段的结构体派生 Serialize 和 Deserialize,会生成数千行代码。在大型项目中,这可能导致编译时间增加 30% 以上。

IDE 支持不足。声明宏的 token 级操作使得 IDE 无法在宏调用处提供准确的自动补全和类型提示。过程宏的情况稍好(因为操作的是 AST),但大多数 IDE 仍然无法展开宏进行语义分析。

适用边界。宏最适合以下场景:消除跨多个类型的重复实现(如 Builder、Serialize)、编译期配置生成(如根据特性门生成不同的 API)、DSL 设计(如测试框架的断言语法)。不适合的场景包括:可以用泛型解决的类型抽象、可以用 trait 解决的行为抽象、仅使用一两次的简单代码生成。

五、总结

Rust 宏系统提供了从 token 级到 AST 级的编译期代码生成能力。声明宏通过模式匹配实现轻量级代码生成,过程宏通过语法树操作实现复杂的派生和属性逻辑。本文展示了 Builder 模式声明宏、BinarySerialize 派生过程宏和参数校验属性宏三个生产级实现。落地路线建议:第一步,从声明宏开始,用 macro_rules! 消除项目中最明显的重复代码;第二步,当声明宏的表达力不足时,引入 syn + quote 实现过程宏,优先编写派生宏(输入结构确定,错误处理简单);第三步,使用 cargo expand 验证宏展开结果,确保生成的代码符合预期;第四步,在 CI 中加入 cargo clippy 检查,对宏生成的代码进行静态分析,防止生成有潜在问题的代码。

在 SAP 中启用应收/应付“代扣税(Withholding Tax)”功能,本质上是激活并配置“扩展代扣税(Extended Withholding Tax)”模型 摘要:SAP中启用应收/应付代扣税功能需完成3个层级12个核心步骤:1)全局激活公司代码代扣税功能;2)配置代扣税规则、税率和科目,包括定义税种类型、代码、总账科目等;3)在供应商/客户主数据中关联代扣税设置。完成后系统可在发票或付款环节自动计算并过账代扣税,支持多税种并行计算和税率年度调整,最终生成税务报表。常见问题排查需检查公司代码激活状态和主数据配置。(149字) 阅读详情

相关推荐

Windows 11 + AMD 780M 运行 ComfyUI 完整指南:DirectML 实战方案

ComfyUI 是基于 PyTorch 的 Stable Diffusion 可视化工作流工具,其性能高度依赖 GPU 后端支持。在 Windows 平台,传统 CUDA 方案仅适配 NVIDIA 显卡,而 AMD 核显用户长期面临 ROCm 兼容性差、驱动链路断裂等系统级障碍。DirectML 作为微软原生机器学习 API,绕过 ROCm 生态断层,直接对接 DirectX 12 硬件抽象层,成为 RDNA 3 架构(如 Radeon 780M)在 Windows 11 上运行 AI 绘画的最优解。它提供

weixin_30099989的博客 752

Rust 宏系统深度剖析:从声明宏到过程宏的完整指南

Rust 宏系统(Macro System)是其元编程(Metaprogramming)能力的核心,分为声明宏(Declarative Macros)和过程宏(Procedural Macros)两大类。声明宏通过模式匹配和代码替换实现简洁的语法糖;过程宏则提供了操作 TokenStream 的能力,可实现自定义派生(Derive)、属性宏(Attribute)和函数宏(Function Macro)。

JarryStudy的博客 1219

MFC 修改CheckBox的文本颜色方法

设置主题 这一步是必须的,不可省略。 BOOL CMFCApplication1Dlg::OnInitDialog() { CDialogEx::OnInitDialog(); // 设置此对话框的图标。 当应用程序主窗口不是对话框时,框架将自动 // 执行此操作 SetIcon(m_hIcon, TRUE); // 设置大图标 SetIcon(m_hIcon, FALSE); // 设置小图标 // TODO: 在此添加额外的初始化代码 // 设置主题 HWND

Kim的博客 2249

Rust 宏系统深度实践:声明宏与过程宏的 DSL 设计从入门到生产级

*** 函数式过程宏(Function-like Proc Macro)* 解析自定义 DSL 语法并生成代码*//// 自定义 DSL:定义状态机/// 用法:state_machine!while!;// 消费 -> 分隔符[->]) {;.collect();// 生成转换逻辑quote!{ None }});quote!

no1coder的博客 4896

告别命令行!用这个开源的Web版Kettle工具,5分钟搞定数据集成任务编排

本文介绍了一款开源的Web版Kettle工具,通过直观的拖拽界面大幅提升数据集成效率,告别复杂的命令行操作。该工具基于Kettle核心引擎,支持跨平台协作、轻量化访问和降低学习曲线,特别适合业务分析师快速上手。实测显示,使用该工具后任务配置错误率下降62%,协作效率提升40%。

weixin_30267785的博客 436

SAP License USMM SLAW2 SAP审计

引言 企业每年都会收到SAP License审计邮件,邮件内容大致就是根据贵公司与SAP签定的合同XXX条款规定,贵公司所安装的SAP系统需要进行测定。 关键字: SAP License、 SAP USMM、 SLAW2、 SAP 账号、SAP 账号审计、 SAP License 审计、 SAP 审计报告、SAP 账号优化 SAP License审计邮件 企业每年都会收到SAP License审计邮件,邮件内容大致就是根据贵公司与SAP签定的合同XXX条款规定,贵公司所安...

感悟人生 2981

Rust 过程宏开发入门:从语法扩展到元编程实践

在主程序中定义Hellotrait:rust过程宏是 Rust 元编程的 “瑞士军刀”,它通过编译期代码生成,让开发者能以灵活的方式扩展语言能力。本文从概念入手,通过一个派生宏案例展示了过程宏的开发流程,核心在于理解 “解析输入语法树→生成输出代码” 的工作流,以及syn和quote的配合使用。入门后,可进一步探索属性宏(如实现一个自动计时的#[timed]宏)、函数式宏(如实现动态 SQL 生成),或研究 serde 如何通过派生宏实现序列化逻辑。

X123456zxcv的博客 1671

R | 提取文件夹内栅格数据的最小值、最大值、标准差和平均值

各位同学好,我们长需要用长时间序列栅格数据的平均值做变量的时间变化分析,用代码能够帮助我们省下很多时间。

qq_48539301的博客 450

Rust中的过程宏开发入门:从原理到深度实践

过程宏是Rust元编程能力的核心,它在编译期操作代码的语法树,生成新的Rust代码。与声明宏(macro_rules!)相比,过程宏拥有完整的编程语言能力,可以执行复杂的逻辑、访问外部资源甚至进行网络请求。这种强大的能力让过程宏成为构建DSL、自动代码生成和编译期优化的关键工具。理解过程宏不仅是掌握一种技术,更是深入理解Rust编译过程和元编程思想的重要途径。过程宏的价值体现在消除样板代码和实现零成本抽象上。

weixin_67582294的博客 1462

Ubuntu16.04下禁用scp、sftp和winscp

在上一篇博文《Ubuntu16.04 搭建FTP服务器,设置用户权限为只许上传、禁止下载和删除》中,我讲述了Ubuntu16.04下配置FTP,并且设定用户权限为只能上传数据,禁止下载和删除数据。这算在FTP层面封堵了服务器数据泄露的途径。 但是,Ubuntu系统的scp和sftp还是起作用的,理论上只要能用本地机器ping通服务器,就可以用scp和sftp下载数据,这还是存在数据泄露可能的,所...

HPC&Geophysics攻城狮 5737

谷歌A2A协议入门指南:附简易Python代码示例

继"关税"之后,当下最热门的词汇当属AI智能体——这种基于人工智能的软件能够执行复杂任务、实现工作流自动化并提升生产效率。但迄今为止,大多数智能体都处于各自为政的状态,难以顺畅协作。就像团队执行重大项目时,成员之间却无法交流!对于技术人员而言,一个可能遇到的典型场景是:假设你需要协调四个不同的AI服务——处理用户查询的Gemini智能体、在向量数据库进行搜索的AI应用、基于Claude的摘要生成器,以及运行专业领域逻辑的Python智能体。

独立开发,substack顶级编辑 802

Rust 过程宏开发入门:编译期元编程的艺术

过程宏代表了 Rust 元编程的巅峰,但也要求开发者具备深厚的语言理解和工程素养。一个优秀的过程宏不仅功能正确,更要考虑编译性能、错误诊断、文档清晰度和使用直观性。在现代 Rust 生态中,理解过程宏已经成为高级开发者的必备技能。建议先从研究现有的流行宏(如serdetokiosqlx)开始,理解它们的设计思路,再逐步实践自己的宏开发。

2501_94019712的博客 830

用 SNC 和 SAP Single Sign-On Secure Login 把 SAP 登录这件小事,变成一件安全又不用输密码的事

在传统的 SAP 系统里,登录这件事看起来很朴素:用户打开 SAP GUI,输入一个 SAP 用户名,再输入一个 SAP 密码,点回车,进系统,开始干活。表面上没毛病,但从安全角度看,这种老办法问题很大。默认情况下,这些用户名和密码在网络上传输时是明文,也就是不加密传输。攻击者如果在公司网络里做监听,理论上可以直接截取到口令信息,这种风险对今天任何一家合规要求高、审计严格的企业来说,基本是不可接受的。(SAP Help Portal)SAP 给出的答案叫做 ,全称是 。SNC 做的事情可以概括成两类:一类是

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 381

少写重复,多写逻辑:从 `macro_rules!` 到过程宏 `derive` 的实战指南

这篇聚焦“编译期生成代码但保持可维护”。先用 `macro_rules!` 解决局部样板与小型 DSL,再上升到过程宏处理跨模块的重复(如自动实现 `Display/From/Builder`、校验入参、插桩日志等)。给出项目拆分与最小依赖组合(`proc-macro` + `syn` + `quote`)、可读可控的代码生成方式、常见坑(卫生、`Span`、递归膨胀、错误信息不友好)与定位技巧(`cargo expand`/最小复现)。最终形成一套“先声明式,后过程宏;先约束,后生成”的实战方法。

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 1203

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

Rust 过程宏开发入门:从原理到实战的深度指南

在 Rust 的元编程体系中,过程宏(Procedural Macros)是最强大且灵活的工具之一。与声明式宏(macro_rules!)相比,过程宏能直接操作 Rust 的抽象语法树(AST),实现代码生成、语法扩展、编译期检查等复杂功能。从serde的#[derive(Serialize)]到tokio的#[tokio::main],过程宏已成为 Rust 生态中众多核心库的基石。

2503_94046484的博客 468

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

还在手动重复代码?用Rust宏+Trait实现自动化行为扩展(稀缺技术揭秘)

告别重复代码!本文教你用Rust特性实现自动化行为扩展,结合宏与Trait简化开发。适用于高频模式复用场景,提升代码可维护性与编译期安全。掌握这一稀缺技术,值得收藏。

AlgoInk的博客 640

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Rust中派生宏(Derive Macro)的工作原理:从编译期到运行时的深度解析

开发自定义派生宏首先需要创建一个过程宏crate,在Cargo.toml中声明。然后使用属性定义派生宏函数。这个函数接收TokenStream并返回TokenStream,中间的逻辑就是解析、分析和代码生成。实践中,强烈建议使用syn和quote库而不是手动操作token。syn的DeriveInput类型可以方便地解析输入,Data枚举区分struct、enum和union,Fields枚举处理命名字段、匿名字段和单元类型。通过模式匹配这些类型,可以清晰地处理各种情况。quote的quote!

m0_65499524的博客 718

Rust 元编程与宏系统:从模式匹配到 AST 操控的深度指南

本文深入剖析了 Rust 宏系统,分为声明宏与过程宏两大类型。声明宏通过macro_rules!实现模式匹配式代码替换,支持卫生性和重复操作符,适合简化重复代码和创建DSL。过程宏则是编译期运行的Rust函数,能直接操作AST,分为派生宏、属性宏和函数宏三种形式,依赖syn、quote等库实现复杂代码生成。文章通过实现Hello派生宏的完整示例展示了过程宏的工作流程。Rust宏系统在保持类型安全的前提下,提供了强大的元编程能力,是构建高效抽象的核心工具。

AtomicVerse的博客 705

RustTraining 宏编程实战:从 C/C++ 预处理器到 Rust 声明式宏、派生宏与过程宏的完整迁移指南

> 本文是 RustTraining 仓库中《Rust for C/C++ Programmers》课程([c-cpp-book](https://link.gitcode.com/i/0e93e3aea50b671c21390d398205c1cd))第 19 章的系统化展开。核心主题是:Rust 宏体系(`macro_rules!` 声明式宏、`#[derive]` 派生宏、属性宏、过程宏)如

gitblog_00403的博客 416

RustMark v0.9:WYSIWYG 渲染 — Rust 宏编程(声明宏+过程宏)深度实战

核心痛点:传统 Markdown 编辑器将编辑区和预览区完全分离——左边写源码,右边看渲染结果。这种"双栏割裂"模式强迫开发者在"写作"和"阅读"两种心智状态之间频繁切换,文本中的**粗体**# 标题[链接](url)等标记符严重干扰对内容本身的感知。更关键的是,当 Markdown 文档规模超过 5000 行时,从编辑区定位到预览区对应位置的认知开销急剧增加。

我的博客 301

十分钟带你入门Rust -- 过程宏开发入门(二)

这里的关键是 syn 和 quote 两个 crate:syn 负责将 token 流解析为结构化的 AST,而 quote 则提供了一种优雅的方式来构造新的 token 流。过程宏(Procedural Macros)是 Rust 元编程能力的核心体现,它允许开发者在编译时操作抽象语法树(AST),实现代码生成、自动化派生和领域特定语言(DSL)的构建。与声明宏(declarative macros)的模式匹配不同,过程宏本质上是在编译期执行的 Rust 函数,这赋予了它几乎无限的表达能力。

Harden_zsc的博客 684

【免费开源】深圳路网SHP数据完全指南:从 sz_shp.7z 解压到 QGIS 导入

做毕设、写交通分析,第一步经常卡在同一个地方:找一份图层齐全、能直接导进 GIS 软件的深圳路网数据。「深圳路网相关shp数据」这个仓库解决的正是这件事——主要公路、小路、铁路、区、街道、河流六类图层,标准 SHP 格式,打包成 sz_shp.7z 压缩包,下载即可用。 ## 资源速览:这份数据里有什么 六类 SHP 路网数据全部装在 [sz_shp.7z](https://link.gitc

gitblog_00907的博客 983

Rust 宏系统的编译期行为

派生宏(Derive)、属性宏(Attribute)和函数宏(Function-like)三类过程宏,分别在编译期自动实现trait、修饰代码块或转换函数签名。在Rust的世界里,宏系统是编译期展开的"代码生成器",它允许开发者在编译阶段对抽象语法树(AST)进行操作,实现传统编程无法完成的元编程魔法。与C/C++简单的文本替换不同,Rust宏通过卫生性(Hygiene)和类型安全的设计,在编译期完成代码转换与验证,既提升了表达力又保障了安全性。Rust宏系统的编译期魔法:代码生成的秘密武器。

tayium_552的博客 410

【Rust 语言编程知识与应用:过程宏详解】

过程宏(Procedural Macros)是 Rust 最强大的元编程工具,通过操作 `TokenStream` + `AST` 在编译期生成任意代码,远超声明式宏的灵活性。核心依赖独立 `proc-macro` crate + `syn`(解析 AST)+ `quote`(生成代码)+ `proc_macro2`(稳定接口)。支持三种形式:函数式宏(`#[proc_macro]`)、派生宏(`#[proc_macro_derive]`)、属性宏(`#[proc_macro_attribute]`)。

小杍随笔技术分享博客 405

(Rust宏性能优化秘籍):让编译期代码生成提速8倍的4项关键技术

掌握Rust宏性能优化核心技巧,解决编译期代码生成缓慢难题。深入解析rust语言宏系统中的惰性求值、声明宏优化、过程宏缓存与代码生成策略,适用于大型项目与高频率编译场景,显著提升构建效率,让编译速度提升8倍,值得收藏。

CompiTide的博客 402

Rust for C 开发者宏入门:从 `!` 后缀到 `macro_rules!` 与过程宏的完整指南

> 本文是 [RustTraining 仓库](https://link.gitcode.com/i/f04424d7720c13cf96a1c707685ccb9d) 中《Rust for C# Programmers》训练书第 12 章的延伸专题([Macros Primer](https://link.gitcode.com/i/c784e3565c4db3e36a8a12d96771a74

gitblog_01192的博客 549
上一篇: 热点函数与内存分配:Python 性能瓶颈的系统性定位与优化
下一篇: LLM 生成 Rust 代码:安全验证与自动修复的工程化方案
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值