rustp-42.宏

Rust中的宏

Rust中的宏主要有两种，一种是使用macro_rules!的声明宏，一种是过程宏，过程宏又
分成三种:
(1) 自定义宏#[derive],在结构体、枚举等上指定通过derive属性添加代码
(2) 类属性宏，定义可以用于任意项的自定义属性
(3) 类函数宏,看起来像是函数，但是作用于作为参数传递的Token
宏和函数
(1) 宏是一种为写其他代码而写代码的方式，对于减少大量编写代码和维护代码非常有用
(2) 一个函数标签必须声明函数参数的个数和类型，宏只接受可变参数
(3) 宏的定义比函数定义更加复杂
(4) 调用宏之前，必须定义并且将其引入作用域，函数但是可以在任何地方调用和定义

声明宏

1	let v = vec![1,2,3];

创建自己的声明宏

1
2
3

mkdir learn
cd learn
vim Cargo.toml

之后，进行设置

//learn/Cargo.toml
[workspace]
members = [
  "mac",
  "main",
]

创建mac lib

1
2
3

cargo new mac --lib
cd mac
vim src/lib.rs

设置mac lib

#[macro_export]
macro_rules! my_vec {//*代表对这个表达式匹配有0个或者多个,模仿vec!
  ($($x: expr), *) => {
    {let mut temp_vec = Vec::new();
      $(
          temp_vec.push($x);
       )*//使用$()*这个语法来捕捉0个或者多个相同的语法
        temp_vec
    }
  };
}

创建main

# /learn
cargo new main
cd main
vim Cargo.toml

修改main

1 2	[dependencies] mac = {path = "../mac"}

写主函数

1	vim src/main.rs

# learn/main/src/main.rs
use mac;

fn main() {
    let v = mac::my_vec![1,2,3];
    //等价于
    //let mut temp_vec = Vec::new();
    //temp_vec.push(1);
    //temp_vec.push(2);
    //temp_vec.push(3);
    //temp_vec
    println!("v = {:?}",v);
  }

过程宏

过程宏接受Rust代码作为输入，在代码上操作，产生另一些代码作为输出，非像声明宏那样
匹配对应的模式，然后以另一部分代码替换当前代码

定义过程宏函数接受一个TokenStream作为输入并产生一个TokenStream作为输出，也就是宏
的核心，宏所处理的源代码组成了输入TokenStream，同时宏生成的代码是输出TokenStream,
如下:

use proc_macro;
#[some_attribute]
pub fn some_name(input: TokenStream) -> TokenStream {

  }

#[derive(Debug)] //过程宏当中的derive宏,fmt::Display trait
struct A {
    a: i32,
  }

自定义derive宏

名称必须为some some_derive这种,与例子相同

首先创建hello_macro

1
2
3

cargo new hello_macro --lib
cd hello_macro
vim src/lib.rs

之后进行编辑

1
2
3

pub trait HelloMacro {
    fn hello_macro();
  }

之后在这个文件夹中新建

# 位置:hello_macro/
cargo new hello_macro_derive --lib
cd hello_macro_derive
vim Cargo.toml

填写:

[lib]
proc-macro = true
[dependencies]
syn = "0.14.4"
quote = "0.6.3"

实现代码填写

extern crate proc_macro;
use crate::proc_macro::TokenStream;
use quote::quote;
use syn;

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

      gen.into()
  }
#[proc_macro_derive(HelloMacro)]
pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
    let ast = syn::parse(input).unwrap();//将其解析成结构体,叫做DeriveInput
    //
    impl_hello_macro(&ast);
  }

使用宏的代码

cd ..
# /
cargo new main
cd main
vim Cargo.toml

编写依赖

1
2
3

[dependencies]
hello_macro = {path = "../hello_macro"}
hello_macro_derive = {path = "../hello_macro_derive"}

编写代码

//main/src/main.rs
use hello_macro::HelloMacro;
use hello_macro_derive::HelloMacro;

#[derive(HelloMacro)]
struct Main;

fn main() {
    Main::hello_macro(); //调用实现的hello_macro特征
    
  }