Rust宏编程实战:从声明宏到过程宏的完整指南

Rust编程基础教程:宏和元编程 1.背景介绍 Rust是一种现代系统编程语言,它具有内存安全、并发原语和类型系统等特点。Rust编程语言的宏和元编程功能是其强大的编程工具之一,可以帮助开发者更高效地编写代码。本文将详细介绍Rust编程基础教程的宏和元编程,包括其核心概念、算法原理、具体操作步骤、数学模型公式、代码实例以及未来发展趋势。 阅读详情

引言

宏是Rust中强大的元编程工具,可以在编译时生成代码。作为从Python转向Rust的开发者,我发现Rust的宏系统与Python的装饰器和元类有很大不同。Rust的宏分为声明宏和过程宏,各有不同的用途。本文将深入探讨Rust宏编程的核心概念和实战技巧。

一、宏基础

1.1 声明宏(Declarative Macros)

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

fn main() {
    say_hello!();
}

1.2 带参数的宏

macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Function {} called", stringify!($func_name));
        }
    };
}

create_function!(foo);
create_function!(bar);

fn main() {
    foo();
    bar();
}

1.3 模式匹配

macro_rules! vec_init {
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec
        }
    };
}

fn main() {
    let v = vec_init![1, 2, 3, 4];
    println!("{:?}", v);
}

二、声明宏进阶

2.1 重复模式

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

fn main() {
    let s = sum!(1, 2, 3, 4, 5);
    println!("Sum: {}", s); // 输出: 15
}

2.2 嵌套宏

macro_rules! debug {
    ($val:expr) => {
        println!("{} = {:?}", stringify!($val), $val);
    };
    ($($val:expr),*) => {
        $(
            debug!($val);
        )*
    };
}

fn main() {
    let x = 42;
    let y = "hello";
    debug!(x, y);
}

2.3 宏辅助函数

macro_rules! calculate {
    (add $x:expr, $y:expr) => {
        $x + $y
    };
    (subtract $x:expr, $y:expr) => {
        $x - $y
    };
    (multiply $x:expr, $y:expr) => {
        $x * $y
    };
    (divide $x:expr, $y:expr) => {
        if $y == 0 {
            panic!("Division by zero");
        }
        $x / $y
    };
}

fn main() {
    let result = calculate!(add 10, 5);
    println!("Result: {}", result); // 输出: 15
}

三、过程宏(Procedural Macros)

3.1 派生宏(Derive Macros)

use proc_macro::TokenStream;
use quote::quote;
use syn;

#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    let ast = syn::parse_macro_input!(input as syn::DeriveInput);
    impl_hello_macro(&ast)
}

fn impl_hello_macro(ast: &syn::DeriveInput) -> TokenStream {
    let name = &ast.ident;
    let gen = quote! {
        impl HelloMacro for #name {
            fn hello_macro() {
                println!("Hello, Macro! My name is {}", stringify!(#name));
            }
        }
    };
    gen.into()
}

trait HelloMacro {
    fn hello_macro();
}

3.2 属性宏(Attribute Macros)

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

#[proc_macro_attribute]
pub fn log(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as ItemFn);
    let ident = &input.sig.ident;
    let block = &input.block;
    
    let gen = quote! {
        fn #ident() {
            println!("Entering function: {}", stringify!(#ident));
            #block
            println!("Exiting function: {}", stringify!(#ident));
        }
    };
    
    gen.into()
}

#[log]
fn my_function() {
    println!("Inside my_function");
}

3.3 函数式宏(Function-like Macros)

use proc_macro::TokenStream;
use quote::quote;
use syn::parse_macro_input;

#[proc_macro]
pub fn make_struct(input: TokenStream) -> TokenStream {
    let name = parse_macro_input!(input as syn::Ident);
    
    let gen = quote! {
        struct #name {
            id: i32,
            name: String,
        }
        
        impl #name {
            fn new(id: i32, name: String) -> Self {
                #name { id, name }
            }
        }
    };
    
    gen.into()
}

make_struct!(User);

fn main() {
    let user = User::new(1, "Alice".to_string());
    println!("User: {} - {}", user.id, user.name);
}

四、宏编程实战

4.1 实现一个ORM框架

macro_rules! model {
    ($name:ident { $($field:ident: $ty:ty),* }) => {
        pub struct $name {
            $(pub $field: $ty),*
        }
        
        impl $name {
            pub fn new($($field: $ty),*) -> Self {
                $name { $($field),* }
            }
            
            pub fn to_sql(&self) -> String {
                format!(
                    "INSERT INTO {} ({}) VALUES ({})",
                    stringify!($name),
                    stringify!($($field),*),
                    format_args!("{},", $(self.$field),*)
                )
            }
        }
    };
}

model!(User { id: i32, name: String, email: String });

fn main() {
    let user = User::new(1, "Alice".to_string(), "alice@example.com".to_string());
    println!("SQL: {}", user.to_sql());
}

4.2 构建一个测试框架

macro_rules! test {
    ($name:ident => $body:expr) => {
        #[test]
        fn $name() {
            let result = $body;
            assert!(result);
        }
    };
    ($name:ident: $expected:expr => $body:expr) => {
        #[test]
        fn $name() {
            let result = $body;
            assert_eq!(result, $expected);
        }
    };
}

test!(addition: 4 => 2 + 2);
test!(multiplication: 6 => 2 * 3);
test!(always_true => true);

4.3 实现依赖注入

macro_rules! inject {
    ($($service:ident),*) => {
        struct ServiceContainer {
            $($service: $service),*
        }
        
        impl ServiceContainer {
            fn new($($service: $service),*) -> Self {
                ServiceContainer { $($service),* }
            }
        }
    };
}

struct Database;
struct Logger;
struct Cache;

inject!(Database, Logger, Cache);

fn main() {
    let container = ServiceContainer::new(Database, Logger, Cache);
}

五、宏的最佳实践

5.1 宏与函数的选择

场景使用宏使用函数
代码生成是否
类型抽象否是
编译时计算是否
性能关键路径否是

5.2 宏的命名规范

// 好的命名:清晰表达宏的用途
macro_rules! vec_of_strings {
    ($($s:expr),*) => {
        vec![$($s.to_string()),*]
    };
}

// 避免模糊的命名
// macro_rules! vs { ... } // 不好

5.3 宏的文档注释

/// 创建一个包含多个字符串的向量
/// 
/// # 示例
/// ```
/// let v = vec_of_strings!["hello", "world"];
/// assert_eq!(v, vec!["hello".to_string(), "world".to_string()]);
/// ```
macro_rules! vec_of_strings {
    ($($s:expr),*) => {
        vec![$($s.to_string()),*]
    };
}

六、从Python视角看宏

6.1 Python装饰器 vs Rust宏

Python装饰器:

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Finished {func.__name__}")
        return result
    return wrapper

@log_decorator
def my_function():
    print("Inside function")

Rust宏:

macro_rules! log {
    ($func:ident) => {
        fn $func() {
            println!("Calling {}", stringify!($func));
            // 函数体
            println!("Finished {}", stringify!($func));
        }
    };
}

log!(my_function);

6.2 优势对比

特性Python装饰器Rust宏
执行时机运行时编译时
代码生成有限强大
类型安全无有
性能影响运行时开销零开销

七、常见陷阱与解决方案

7.1 宏的递归限制

// 问题:宏递归深度限制
macro_rules! recursive {
    (1) => { 1 };
    (n) => { n + recursive!(n - 1) }; // 可能无限递归
}

// 解决方案:使用模式匹配终止
macro_rules! factorial {
    (0) => { 1 };
    (1) => { 1 };
    ($n:expr) => {
        $n * factorial!($n - 1)
    };
}

7.2 宏中的变量捕获

// 问题:变量作用域问题
macro_rules! bad_macro {
    ($x:expr) => {
        let y = 10;
        $x + y
    };
}

fn main() {
    let y = 20;
    let result = bad_macro!(y); // 使用的是宏内的y=10,不是外部的y=20
    println!("{}", result); // 输出: 20,不是30!
}

// 解决方案:使用唯一标识符
macro_rules! good_macro {
    ($x:expr) => {
        let _macro_y = 10;
        $x + _macro_y
    };
}

7.3 宏的错误处理

// 问题:宏中的错误信息不够清晰
macro_rules! divide {
    ($x:expr, $y:expr) => {
        if $y == 0 {
            panic!("Division by zero");
        }
        $x / $y
    };
}

// 解决方案:提供详细的错误信息
macro_rules! safe_divide {
    ($x:expr, $y:expr) => {
        match $y {
            0 => panic!("Division by zero in {} / {}", stringify!($x), stringify!($y)),
            _ => $x / $y
        }
    };
}

八、总结

Rust的宏系统是强大的元编程工具,可以在编译时生成代码。宏分为声明宏和过程宏,各有不同的用途:

  1. 声明宏:使用macro_rules!定义,适合简单的代码生成
  2. 过程宏:使用proc_macro crate,适合复杂的代码转换
  3. 派生宏:为结构体自动实现Trait
  4. 属性宏:为函数或结构体添加属性
  5. 函数式宏:像函数一样调用的宏

通过掌握宏编程,你可以编写出更加简洁、高效的Rust代码。


参考资料:

Rust语言中的宏 2010年9月1日,Rust编程语言正式发布,这个由 Mozilla、Dropbox 和其他一些企业领导开发的开源系统级编程语言已经吸引了越来越多的开发者和公司投入到其项目中进行尝试。相对于C/C++或者Java这样传统的编译型语言而言,Rust提供了一种全新的编程模型——安全的并发和高效的内存管理机制,让开发者能够在不破坏性能的前提下实现更复杂的功能。但是Rust作为一门新兴的语言,它的学习曲线较陡峭,并且由于没有经过完整的教育或培训机构的支持,很多开发者都会产生一些误区,甚至出现一些奇怪的问题。 阅读详情

相关推荐

Rust宏编程实战:声明宏与过程宏的工程化应用

Rust 的宏系统从的模式匹配到过程宏的 AST 操作,提供了从简单到复杂的完整元编程能力。掌握宏编程的关键在于理解的转换流程,以及 syn/quote 生态提供的工程化工具。通过本文的 Builder 派生宏和计时属性宏实战,你应该已经具备了开发自定义过程宏的能力。记住,优秀的宏应该让使用者感觉不到宏的存在——它生成的代码就像手写的一样自然、类型安全、错误信息友好。

从事移动开发八年,csdn博客专家,阿里云特邀专家,华为云云享专家,高级网络信息安全工程师,大数据工程师(高级),python技术开发(高级),HarmonyOS 应用开发者高级认证,现在某学校任教。 29

rust宏(macro)详解

rust宏解析

白嫩豆腐 2477

IROS 2025机器人技术解析:从诡异设计到硬核应用

机器人技术正从传统的结构化环境应用,迈向复杂非结构化场景的深度交互。其核心原理在于通过仿生设计、多模态感知与智能控制算法,赋予机器人类似生物的适应性与交互能力。这一技术演进的价值在于突破传统机器人在极端环境、精密操作和自然交互中的瓶颈。例如,结合深度强化学习的全身动力学控制,使机器人能在废墟、管道等复杂地形中自主导航;而软体机器人技术则通过材料变形实现安全、柔顺的抓取操作。这些技术最终服务于极端环境巡检、精密装配和高端陪护等刚性应用场景,推动机器人从功能实现迈向与环境、人进行深度、智能交互的新阶段。

weixin_34006468的博客 453

Rust 中的宏

宏(macro) 是 Rust 中的一种高级特性,Rust 中的宏分为两种: 声明性宏(declarative macros) 程序宏(procedural macros) Custom #[derive] macros Attribute-like macros Function-like macros 宏与函数的区别 函数不能接收任意多个参数,而宏可以。 函数不能操作语法单元,而宏可以。从根本上说,宏是用来生成代码的。 函数在编译之前不需要特殊处理,声明性宏需要在编译之前进行展开,展开之后代

花落花开的博客 8383

王道考研操作系统笔记(第一章)附:王道考研408所有PPT和思维导图

学习感想 别人的笔记对你的学习基本上没有用处,容易培养人的惰性,如需ppt和思维导图请拉到最后,有github链接 记笔记并不是一件浪费时间的事情,还有利于多次学习 真心希望大家在学习的过程中记笔记 操作系统 第一章 计算机系统概述 1.1 操作系统 1.1.1 操作系统的概念和功能 概念 操作系统(Operating System, OS)是指控制和管理整个计算机系统的硬件和软件资源,并合理地组织调度计算机的工作和资源的分配;以提供给用户和其他软件方便的接口和环境;它是计算机系统中最基本的系统软

qq_41732756的博客 1万+

aubo i5 + realsense D435i识别抓取实践二

aubo i5 + realsense D435i识别抓取实践二前言一、手眼标定是什么?二、标定软件安装1.aruco_ros安装2.vision_visp安装3.easy_handeye安装4.realsense驱动安装5.安装realsense ROS软件包三、配置1.launch文件修改2.打印二维码四、手眼标定1.启动launch文件2.标定步骤3.发布tf关系 前言 前面配置好了aubo机械臂的ROS软件包,机械臂可以正常运行后,接下来我们进行机械臂与相机的手眼标定。手眼标定分为eye_on_ha

转角 6377

Rust中的过程宏

过程宏是rust里的强大的武器,非常值得学习rust的人去掌握。但过程宏的编写有点难度,且文档也不太详细,最近也专门学习了下过程宏,算是有点收获,写下一点东西。

猫哥 的沉淀、积累、总结。天天学习,好好向上...c/c++,嵌入式 linux,Android,HarmonyOS,AIOT) 3297

C语言手写HTTPD网站服务器

零基础手写C语言http网站服务器,快速入门C/C++后端开发、服务器开发。

程序员Rock的博客 1万+

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

汇编语言(第4版)王爽 课程设计2 详细实现(一、虚拟模式DOS运行篇)

由于虚拟模式的限制,我们编写的许多逻辑暂时不能被检验,而因为《汇编语言》编写时间较早,其所依赖的运行环境如今只能够依靠虚拟机来搭建。比如实模式DOS,搭建步骤比较繁琐,因此我将其它的部分放在下一篇文章中进行讲解。事实上,我们实现的程序属于《汇编语言》课程设计2中任务程序部分,其中的完整任务还涉及到将该任务程序安装到软盘等操作,这些也都需要在实模式下才能运行,所以统一放到下一篇文章进行实现。

m0_73327328的博客 2825

华为OD机试 - 整型数组按照个位数排序(Python/JS/C/C++ 双机位C卷 100分)

本专栏收录于《华为OD机试真题(Python/JS/C/C++)》。刷的越多,抽中的概率越大,私信哪吒,备注华为OD,加入华为OD刷题交流群,每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景,发现新题目,随时更新。给定一个非空数组(列表),其元素数据类型为整型,请按照数组元素十进制最低位从小到大进行排序,十进制最低位相同的元素,相对位置保持不变。当数组元素为负值时,十进制最低位等同于去除符号位后对应十进制值最低位。给定一个非空数组,其元素数据类型为32位有

学Java,找哪吒 400

Rust 宏编程实战:从声明宏到过程宏

/ lib.rs/// 自动实现 Builder 模式// 提取字段_ => panic!("Builder 只支持命名字段"),_ => panic!("Builder 只支持结构体"),// 生成 builder 字段声明quote!});// 生成 setter 方法quote!self});// 生成 build 方法quote!});

2301_76618579的博客 567

【好物推荐】MQTTX 快速入门使用指南

摘要:MQTTX是一款跨平台MQTT客户端工具,支持MQTT 5.0/3.1.1协议,提供桌面版、网页版和CLI版本。本文介绍了快速入门指南,包括下载安装、核心概念解释、连接公共MQTT服务器(broker.emqx.io)的步骤,以及订阅主题、发布和接收消息的操作流程。文章还提供了常见问题排查方法,帮助用户快速完成MQTT开发调试的基本操作。

奶爸的编程之路,也就一周冷个三天 888

Rust Rosetta Code宏编程:从声明式宏到过程宏的进阶指南

Rust Rosetta Code项目通过实现各种算法和问题展示了Rust语言的强大能力,其中宏编程是提升代码复用性和表现力的核心技术。本文将带你探索Rust宏编程的完整路径,从基础的声明式宏到高级的过程宏,掌握如何利用宏简化复杂逻辑并编写出更优雅的Rust代码。 ## 声明式宏:Rust宏编程的入门钥匙 🗝️ 声明式宏(Declarative Macros)是Rust中最常用的宏类型,通过

gitblog_00481的博客 374

8-bit量化在YOLOv11中的部署实践-(使用PTQ、QAT量化技术实现模型体积压缩和推理加速)

本文系统介绍了YOLOv11模型量化技术,主要包括三个核心部分:首先阐述模型量化的基础理论,包括量化分类、数学原理和性能影响;其次分析YOLOv11架构特点及其量化敏感层;最后详细讲解训练后量化(PTQ)的具体实现流程。研究表明,8-bit量化可使YOLOv11模型大小缩减至1/4,推理速度提升1.7-2.3倍,精度损失控制在1%以内。文章特别强调了校准算法选择(如最小最大值法和KL散度法)对量化效果的关键影响,并提供了完整的代码实现示例,为YOLOv11的高效部署提供实用指导。

本博客聚焦 YOLOv11 全流程落地,涵盖架构优化、数据集处理、训练技巧与多场景部署,兼及国产数据库、Java 开发与 AI 模型应用,内容兼顾理论与工程实践,为开发者提供系统干货,助力高效提升技术能力。 1630

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

Rust宏编程:声明宏与过程宏对比及DSL开发实践

宏编程是现代编程语言中的重要特性,它允许开发者在编译时进行代码生成和转换。Rust语言提供了类型安全的宏系统,主要包括声明宏和过程宏两种形式。声明宏基于模式匹配实现简单代码生成,而过程宏则能处理完整语法树,支持更复杂的逻辑。这种能力使Rust宏特别适合实现领域特定语言(DSL),可以显著提升代码表达力和开发效率。在实际工程中,宏被广泛应用于Web框架路由定义、ORM模型生成等场景,结合syn和quote等工具库,开发者可以构建类型安全且高性能的DSL解决方案。

weixin_30588675的博客 373

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

Rust宏编程完全指南:从基础到高级的元编程艺术

本文深入探讨了Rust强大的宏系统,包括声明式宏和过程式宏两大类型。声明式宏基于模式匹配和卫生性设计,适合处理重复代码模式;而过程式宏则提供了更灵活的编译期代码生成能力,可实现派生宏、属性宏等多种功能。文章还介绍了高级宏技巧如递归宏和TT咀嚼器模式,并提供了调试宏的方法。Rust宏系统是其元编程能力的核心,能显著提升代码表现力和开发效率。

厚积薄发的博客 1992

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Rust宏编程详解:从声明式到过程宏的完整指南

宏是一种元编程工具,允许我们在编译时生成代码。与函数不同,宏在编译期展开,可以处理任意数量的参数。Rust的宏系统是一个强大的元编程工具,允许我们在编译时生成代码。通过掌握声明式宏和过程宏,我们可以创建更加简洁、可维护的代码。关键要点:声明式宏:使用定义,适合简单的代码生成过程宏:使用proc_macrocrate,适合复杂的代码转换使用quote和syn:简化宏的编写避免过度使用:宏应该用于代码复用,而不是滥用添加文档:提高宏的可使用性。

no1coder的博客 4530

Rust宏编程:声明宏与过程宏在DSL开发中的应用

宏编程是现代编程语言中实现元编程的重要技术,通过在编译期进行代码生成和转换,能够显著提升代码的复用性和表达力。Rust语言提供了声明宏和过程宏两套系统,分别适用于不同复杂度的元编程需求。声明宏基于简单的模式匹配机制,适合实现语法糖和基础DSL;而过程宏则能访问完整的语法树,支持更复杂的逻辑处理和领域特定语言开发。在工程实践中,合理运用宏系统可以构建类型安全的领域特定语言(DSL),减少样板代码,同时保持编译期检查的优势。特别是在Web框架、序列化库、配置系统等场景中,Rust宏已成为实现优雅API的关键技术

weixin_42563415的博客 275

10-Rust 宏编程(声明式宏 + 过程宏 + syn/quote + 宏调试 + 自定义序列化宏)

本文深入讲解 Rust 宏编程核心知识,涵盖声明式宏(macro_rules!)、过程宏(派生宏、函数宏、属性宏)、syn 和 quote 库使用、宏调试技巧、实战自定义序列化宏等核心内容。每个知识点配有完整代码示例、对比表格、实战场景及常见问题解答,帮助开发者掌握 Rust 元编程能力。

2301_78939167的博客 272

teach-rs宏编程教学:如何编写可重用的代码生成器

teach-rs是一个模块化、可重用的Rust大学课程项目,其中宏编程作为Crate工程设计的重要模块,为开发者提供了强大的代码生成能力。本文将带你快速掌握宏编程的核心概念与实践技巧,帮助你编写可重用的代码生成器。 ## 为什么宏编程是Rust开发者的必备技能? 在Rust开发中,宏(Macro)是一种元编程工具,它允许你在编译时生成代码,从而减少重复劳动并提高代码的可维护性。teach-rs

gitblog_00424的博客 811

Rust 宏编程与 Cargo 插件开发:从代码生成到构建流程扩展

本文从声明宏到过程宏再到 Cargo 插件,系统覆盖了 Rust 宏编程的核心知识。声明宏()适合简单的代码模板生成,基于模式匹配和递归展开,学习成本低但表达能力有限。过程宏(派生宏、属性宏、函数宏)可以操作完整的 AST,表达能力强大但开发复杂度高,必须放在独立 crate 中。synquotesyn解析代码为 AST,quote将 AST 结构生成代码。Cargo 插件通过cargo-xxx命名约定自动注册,可以扩展构建流程和开发工具链。

no1coder的博客 2681

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

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

我的博客 301

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

rust-gpu 过程宏揭秘:深入解析 `spirv-std-macros` 与 `[spirv(..)]` 属性宏

> **导读**:`spirv-std-macros` 是 rust-gpu 项目中为 GPU 着色器标准库 `spirv-std` 提供过程宏(proc-macro)支撑的核心 crate。本篇文章将以 [crates/spirv-std/macros/README.md](https://link.gitcode.com/i/89d8972e887608f69a16c3bffa5c7d7b)

gitblog_00010的博客 1147

RustTraining 宏编程实战:从 macro_rules! 到 syn + quote 的过程宏

> 本文是 RustTraining 开源训练仓库中 [rust-patterns-book](https://link.gitcode.com/i/4d54b90ac75429c595a9d7e2d648a49e) 第 13 章的完整展开,系统讲解 Rust 宏系统的两大分支——声明式宏(`macro_rules!`)与过程宏(derive / attribute / function-like

gitblog_00007的博客 498
上一篇: Python异步编程深度解析:从asyncio到实战应用
下一篇: Python单元测试最佳实践:从pytest到测试驱动开发
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值