pdf版本方便阅读
- 前言
"FFI"是" Foreign Function Interface"的缩写，大意为不同编程语言所写程序间的相互调用。鉴于C语言事实上是编程语言界的万国通，世界通用语，所以本文主要围绕着C和Rust之间的互通来学习。
单刀直入，话不啰嗦，好比学外语， 先要从认字开始， 对于编程语言来说就是各种“基础类型”， 因为类型代表了：可操作集和布局， 有人会疑问“类型布局”是个什么东西？！ 好吧， 换个词“房屋布局”， 这词的意思，您好理解吧！对！代表了：位置、大小、方向，排列、顺序等信息！在类型的基础上，进一步考虑：类型的组合(打包封装对齐)方式， 这也好理解吧！毕竟人与人沟通光蹦字还不行， 字组合起来才有意思呀！再下一步就是“函数声明”，代表着想去干一件事情！首先要描述清楚：比如：函数类型、输入参数、结果类型、函数调用规约（如：__stdcall、_cdecl等等好多，代表函数栈的使用和清理、函数调用参数的入栈顺序、排列方式， 函数返回指针等）， 下一步内存管理问题， 彼此互传的数据对象该如何划分和管理其生命周期！避免出现“悬指针和泄露”， 最后还要有回调函数或闭包之类用于状态通知！好比好朋友，别什么事都等我自己主动去问，你最好时不时主动告诉我呀！
当然将上面两种编程语言编写的代码统一管理起来，还需要相应机制，解决诸如：编译构建，库生成和引用等问题。
此篇Rust FFI文章比较全面：`/nomicon/`
- 基础类型
每一种编程语言都可能定义许多“基础类型”， 两种编程语言的基础类型之间最好有一个交集， 这样才能传递数据， 所以：Rust std::ffi 和 The libc crate就是非常重要的C and Rust的基础类型交集，
它俩是语言互通的一个前提基础，Rust std::ffi模块提供了诸如： c_void、 CString 、 CStr、OsString 、 OsStr等和Rust自己的字符串类型：String 和str 之间的转化类型。详情请参看：`/std/ffi/` 。 而the libc crate 则封装了更加丰富的C数据类型和API ，诸如：c_void、c_char、c_float、c_double、c_int、c_long、c_schar、c_uint等， 详情请参看：`/libc/0.2.70/libc/` 。`std::os::raw也同样定义了一些C基础类型` ， 这3者存在重叠交集， 一般使用前两个就足矣。
- C and Rust 混合工程管理
Rust 不支持源代码级别直接与其他语言的交互， 也就是说不支持直接在Rust code 中直接embed内嵌其他编程语言代码！只支持以二进制库的方式来互相调用，所以语言界限清晰明确，
避免诸多问题。当然有第三方crate以宏的方式间接支持了在Rust code中内嵌其他语言代码， 详情请参看：`/mystor/rust-cpp` 。
（1）Rust支持的库类型：
- lib — Generates a library kind preferred by the compiler, currently defaults to rlib.
- rlib — A Rust static library.
- staticlib — A native static library.
- dylib — A Rust dynamic library.
- cdylib — A native dynamic library.
- bin — A runnable executable program.
- proc-macro — Generates a format suitable for a procedural macro library that may be loaded by the compiler.
注意： 其中cdylib和staticlib就是与C ABI兼容的。
(2 ) Build C code to a static or dynamic library
#全手动构建C动态库on Linux with gcc #gcc -Wall -fPIC -c #gcc -shared -o #---------------------------------- #全手动构建C静态库on Linux with gcc #gcc -c #gcc -c #ar rcs #---------------------------------- #gcc option: -I 查找头文件位置， -L 查找库位置 ， -l 小写l指示库名字
(3) Rust call C [rust 工程位置：rust_learn/unsafe_collect/ffi/rust2c/manual_build_1]
//manual_build_1工程目录树形结构 . ├── ├── ├── src │ └── └── 1 directory, 4 files
// //下面的shell 命令行用于编译构建一个c static // gcc -c -Wall -Werror -fpic //for dynamic library //gcc -c //for static library. //ar rcs //for static library int add(int a, int b) { return a +b; }
//RUSTFLAGS='-L .' cargo run //-L 用于告诉rustc 库位置。 use std::os::raw::c_int; //(1) 必须使用rust and c都认识的数据类型。 //(2) 这个rust属性用于按名指定链接库，默认链接动态库，除非kind设定static指定链接静态库。 //相当于 -l 的作用 //rustc 发现动态库没找到，它就自动去找静态库， 只要名字相同。 #[link(name="test")] //#[link(name = "test", kind = "static")] //(3) 申明外部函数遵守C语言函数调用规约。 extern "C" { fn add(a: c_int, b: c_int) -> c_int; //此声明函数实际定义在C库中，由上面link属性指定。 } fn main() { //(4) Rust 规定，只允许在unsafe块中调用FFI extern fn. let r = unsafe{add(2, 3)}; println!("{}", r); }
（4）向rustc 传参的几种方法
（a）rustc -L 指定库搜索位置 -l 库名
（b) RUSTFLAGS='-L my/lib/location' cargo build # or cargo run
(c) rustc-link-search 相当于-L , 具体解释看下面代码例子
# 编辑， 指定启用 用于在开始构建rust code之前首先执行，构建好各种依赖环境，如提前构建好C库。 [package] name = "link-example" version = "0.1.0" authors = ["An Devloper <@>"] build = "" #关键点
//编辑 fn main() { //关键就是这个println!, 将rustc-link-search设定为我们自己实际的C库路径就好。 println!(r"cargo:rustc-link-search=库的位置目录"); }
【更多方法请您参看：`/questions/40833078/how-do-i-specify-the-linker-path-in-rust` 和 `/cargo/reference/`】
以及`/cargo/reference/#outputs-of-the-build-script`和`/cargo/reference/`
上面的rust工程例子只是通过手动一个个敲命令来构建的， 十分繁琐， 只适用于展示原理， 实际工程不可取。下面开始研究几个自动完成C and Rust 工程编译构建的例子。
#下面是build_c_lib_by_gcc工程目录树形结构,里面包含了C代码文件。 . ├── ├── └── src ├── └── 1 directory, 4 files
#配置 [package] name = "build_c_lib_by_gcc" version = "0.1.0" authors = ["yujinliang <285779289@>"] edition = "2018" build="" #关键点，启用构建脚本。 # See more keys and their definitions at /cargo/reference/ [dependencies]
// use std::process::Command; use std::env; use std::path::Path; fn main() { let out_dir = env::var("OUT_DIR").unwrap(); //下面直接调用gcc生成C库，并未考虑跨平台问题，切切！ Command::new("gcc").args(&["src/", "-c", "-fPIC", "-o"]) .arg(&format!("{}/", out_dir)) .status().unwrap(); Command::new("ar").args(&["crus", "", ""]) .current_dir(&Path::new(&out_dir)) .status().unwrap(); //上面的代码很直观，就是编译C 代码，构建静态库的命令行， 生成的C库存放到"OUT_DIR"环境变量指定的目录。 //其实您完全可以举一反三， 通过编写构建脚本，可以调用诸如gcc, ar, make,cmake等C/C++构建工具为Rust工程提前生成C库。 //我想您能想到， 肯定是在开始构建编译Rust工程之前执行的！用于预处理。 //下面很关键，配置cargo的官方指定方法之一 ！ println!("cargo:rustc-link-search=native={}", out_dir); //配置C库的搜索路径，相当于rustc -L println!("cargo:rustc-link-lib=static=hello"); //配置需要链接的C库名, 相当于rustc -l println!("cargo:rerun-if-changed=src/"); //告诉cargo工具，只有当“src/”这个文件发生变化时，才重新执行脚本。 }
//src/ //注意：此处没有使用#[link]属性指定需要链接的C库， 因为我们在构建脚本中已经设定好了， //rust cargo 知道该去链接那个C库。 extern "C" { fn hello(); } fn main() { unsafe { hello(); } }
// src/ #include <> void hello() { printf("Hello, World!\n"); }
the cc crate可以帮助我们自动处理构建编译C/C++库的繁琐过程， 同时自动检测平台和架构，自动选择编译器，构建工具， 设定好编译参数， 设定好相关cargo 指令和环境变量等， 高效简洁，下面我们看看例子。
#cc_auto_build_c_lib工程目录结构 . ├── ├── ├── └── src ├── └── 1 directory, 5 files
[package] name = "cc_auto_build_c_lib" version = "0.1.0" authors = ["yujinliang <285779289@>"] edition = "2018" build="" #启用构建脚本。 # See more keys and their definitions at /cargo/reference/ [build-dependencies] #用于配置用到的各种依赖项。 cc = "1.0.53" #自动构建编译C/C++代码。 [dependencies]
// fn main() { //the cc crate专门自动构建编译C/C++ code, //如：自动检测：系统平台， 硬件架构， 自动选择相应编译器，设定各种编译参数， //自动设定相关环境变量， 如：cargo相关环境变量， 自动将编译好的C库保存到“OUT_DIR” //所以cc可以自动帮你搞定诸如：交叉编译， 跨平台。 //cargo build -vv 可以看到已经自动设定的各种构建参数。 //详情请参考：`/cc/1.0.53/cc/` cc::Build::new() .file("src/") .compile("hello"); println!("cargo:rerun-if-changed=src/"); //告诉cargo 只有当src/发生变化时，才重新执行脚本。 }
//src/ //注意：此处没有使用#[link]属性指定需要链接的C库， 因为我们在构建脚本中已经设定好了， //rust cargo 知道该去链接那个C库。 extern "C" { fn hello(); } fn main() { unsafe { hello(); } }
//src/ #include <> void hello() { printf("Hello, World!\n"); }
如何自动检测并链接到操作系统中已有的C库，自动检测库名，库版本，库类型等等，自动设定好cargo相关参数, 类似Linux pkg-config工具， the pkg-config crate就是对应实现，
详情请看：`/pkg-config/0.3.17/pkg_config/` ， 和`/cargo/reference/`
(5) C call Rust
C 和 Rust互通， 需要满足3大原则：
（1）extern "C" 修饰Rust 函数。
（2）#[no_mangle] 修饰Rust函数， 使得C Linker认得Rust函数名。
(3) C and Rust 都认识的数据类型，并且具有相同的内存布局。
---
强调3点：
(4) C 和Rust互相传递数据对象，因为跨越编程语言边界， 所以 必须慎重考虑其回收和释放问题， 避免出现“悬指针”或“内存泄露”问题。
(5) 避免Rust panic跨越边界危及C code, 采用std::panic::catch_unwind包装可能发生panic的rust code , 从而避免panic蔓延。
Rust语言在设计时就把与C互访作为一个重点考虑， 比如与C ABI兼容， 从而做到二进制互访， 以库的形式， 最大化利用C语言世界通用语的巨大优势！Rust通吃硬件、嵌入式、操作系统等。
(6) C和Rust通过回调函数之类互通数据状态， 在多线程、异步等并发情况，若访问全局/静态变量时，请慎重考虑“竞态保护”，如锁保护， 或是采用rust channel之类读写， 以免状态错乱。
Rust官方推荐使用bindgen/cbindgen工具来自动生产C/Rust兼容代码， 因为这两个Rust crate都有Rust官方开发人员加入， 可以确保及时准确与Rust更新保持一直！！！
毕竟Rust非常年轻活跃， 进化飞速， 所以Rust语言本身及Rust FFI都在不断演化！
【Rust to C 字符串】
| Rust type |
Intermediate |
C type |
| String |
CString |
*char |
| &str |
CStr |
*const char |
| () |
c_void |
void |
| u32 or u64 |
c_uint |
unsigned int |
| etc |
... |
... |
详情请看：`/book/interoperability/#interoperability`
【build Rust to a c lib】
#(1) cargo new xxxx --lib #(2) 编辑 [lib] name = "your_crate" #库名， 默认库名就是[package]中定义的name。 crate-type = ["cdylib"] # Creates dynamic lib #与C兼容的动态库。 # crate-type = ["staticlib"] # Creates static lib #与C兼容的静态库。 #(3) cargo build --release
详情请看：`/book/interoperability/`
【link to rust cdylib/ staticlib from c project】
#/unsafe_collect/ffi/c2rust/box_t 项目结构 #cargo build 在target/debug/中生成和 . ├── ├── └── src ├── c_call_rust.c └── 1 directory, 4 files
[package] name = "box_t" version = "0.1.0" authors = ["yujinliang <285779289@>"] edition = "2018" # 定义rust 库名和库类型。 [lib] name = "box" crate-type = ["cdylib", "staticlib"]
//src/ #[repr(C)] #[derive(Debug)] pub struct Foo; #[no_mangle] pub extern "C" fn foo_new() -> Box<Foo> { Box::new(Foo) } // C `s NULL pointer 对应rust Option::None #[no_mangle] pub extern "C" fn foo_delete(f: Option<Box<Foo>>) { println!("{:?}",f ); }
//c_call_rust.c #include <> // Returns ownership to the caller. struct Foo* foo_new(void); // Takes ownership from the caller; no-op when invoked with NULL. void foo_delete(struct Foo*); int main() { foo_delete(foo_new()); foo_delete(NULL); //C的空指针NULL 对应为Rust中的Option::None }
首先 cargo build 生成C库, 静态库： 、动态库：
其次动态链接: gcc -o cm src/c_call_rust.c -L target/debug/ -lbox
最后运行： LD_LIBRARY_PATH=target/debug/ ./cm
详情请看：`/rust-ffi-omnibus/`
若要gcc静态链接, 如下两种方法都可以：
(1)# gcc -o cm src/c_call_rust.c -l: -L target/debug/ -lpthread -ldl
(2)# gcc -o cm src/c_call_rust.c -L target/debug/ -Wl,-Bstatic -lbox -Wl,-Bdynamic -lgcc_s -ldl -lpthread
注意：-Wl,-Bstatic -l静态库名 , 这几个gcc参数强制要求gcc静态链接静态库。
-Wl,-Bdynamic -l 动态库名， 强制要求gcc动态链接库。注意“绿色部分参数间不要有空格，否则无效”；
-l:静态库全名， 如：-l: ， 也是要求gcc静态链接这个库。
【The bindgen crate】
扫描C/C++ code , 从而自动生成对应的Rust code， 如：函数声明， 类型定义等，主攻Rust call C。
// bindgen 扫描 C code。 typedef struct Doggo { int many; char wow; } Doggo; void eleven_out_of_ten_majestic_af(Doggo* pupper); //------------------------------------------------------ // //bindgen 自动生成对应的Rust code //从下面生成的Rust code可以看出:Rust call C需要遵循的原则： //(1) 双方都认识的数据类型。 （2）数据类型的排列，对齐方式要与C一致,即相同的内存布局。（3）函数调用规约要与C一致， 即extern "C" 。 //(4) 双方互传的数据对象的回收释放问题要慎重， 避免“悬指针”。 #[repr(C)] pub struct Doggo { pub many: ::std::os::raw::c_int, pub wow: ::std::os::raw::c_char, } extern "C" { pub fn eleven_out_of_ten_majestic_af(pupper: *mut Doggo); } //有了C code相应的Rust声明和定义， 再link到指定C库， 就可以调用C函数啦。
【The cbindgen crate】
扫描Rust code , 从而自动生成对应的C/C++ code, 如：函数声明， 类型定义等, 主攻于C call Rust 。
//扫描 rust code //repr(C) 和 pub 都要有的类型定义才会被自动生成C code。 #[repr(C)] #[derive(Copy, Clone)] pub struct NumPair { pub first: u64, pub second: usize, } //自动生成C code typedef struct NumPair { uint64_t first; uintptr_t second; } NumPair;
//扫描一个Rust 函数 #[no_mangle] //这个属性必须要有，确保C linker认得Rust的函数名。 pub extern "C" fn process_pair(pair: NumPair) -> f64 { //pub extern "C" 表明只有公开且与C调用规约一直的Rust函数才会被自动生成C code，当然参数类型也要与C匹配才行。 ( as f64 * as f64) + 4.2 } //自动生成C code double process_pair(NumPair pair);
有了Rust code相应的C 声明和定义， 再link到指定Rust库， 就可以调用Rust函数啦！ 详情请看：`/post/2019-05-15-rust/` , `/crates/bindgen` , `/crates/cbindgen` 。对于库的链接方法， Rust和C一样， 比如：rustc /gcc -L 库搜索路径 -l 库名 /... ；当然cargo也有相应的配置方法。
Rust 不允许源代码级别和其他编程语言的互访机制！因为代价太大，并且干扰太大！所以Rust只提供二进制库的形式的互访， 遵循同样的内存布局和函数调用规约， 那么就可以互访！！！相互界限明确，避免互相干扰！！！
【The cpp/cpp_build crate】
the cpp 和cpp_build crate 使得直接在Rust 源码中写C/C++ 源码 成为可能！
///yujinliang/rust_learn/tree/master/unsafe_collect/ffi/rust2c/write_c_in_rust use cpp::*; cpp!{{ #include <> }} fn add(a: i32, b: i32) -> i32 { unsafe { cpp!([a as "int32_t", b as "int32_t"] -> i32 as "int32_t" { printf("adding %d and %d\n", a, b); return a + b; }) } } fn main() { println!("{}", add(1, 7)); }
详情请看：`/post/2019-05-15-rust/` ， `/cpp/0.5.4/cpp/` , `/crates/cpp`
【Box<T> in FFI, c call rust】
从Rust 1.41.0开始，我们已经声明了一个Box<T>，其中T:size现在与C语言的指针（T*）类型ABI兼容。因此，如果有定义了一个extern“C”Rust函数，从C调用，那么Rust函数的输入参数类型和返回参数类型可以为Box<T>，而相应的C函数声明中对应参数的类型为C语言的T* ， 强调一下，这一特性只在C调用Rust的情况下成立， Box<T>拥有所有权，负责管理内存的回收释放， 而C方只是使用，
不关心也不负责其内存的回收和释放！当然C代码也要遵守规矩， 不允许私自释放T*, 也不要超越其生命周期使用T*, 如下：
// C header // Returns ownership to the caller. struct Foo* foo_new(void); //此处返回值类型相当于Rust Box<Foo> // Takes ownership from the caller; no-op when invoked with NULL. void foo_delete(struct Foo*);// 此处C函数输入参数类型相当于Rust Option<Box<Foo>> .
//对应Rust code #[repr(C)] pub struct Foo; #[no_mangle] pub extern "C" fn foo_new() -> Box<Foo> { //此处返回值类型相当于C struct Foo*。 Box::new(Foo) } // The possibility of NULL is represented with the `Option<_>`. #[no_mangle] pub extern "C" fn foo_delete(_: Option<Box<Foo>>) {} //此处Rust 函数输入参数相当于C struct Foo* 和其为NULL时的情况。
再次强调一下，上面的代码只在C call Rust情况下有效！ 但反过来Rust call C 时， 函数声明定义在Rust , 而函数实现定义在C, 此时Rust对于C创建的对象没有所有权， 只能使用， 回收和释放都由C掌控！通俗的将，谁生的孩子谁养！双方都遵守这个江湖规矩，一片祥和！若是违反大家都完蛋。详情请看：``
(6) 自动生成rust code
#下面是一个rust 工程目录树形结构 . ├── ├── └── src └── 1 directory, 3 files
#配置 [package] name = "code_generate" version = "0.1.0" authors = ["yujinliang <285779289@>"] edition = "2018" build="" # 关键点，启用构建脚本。 # See more keys and their definitions at /cargo/reference/ [dependencies]
// rust cargo构建脚本： use std::env; use std::fs; use std::path::Path; fn main() { //"OUT_DIR" 告诉cargo 此build脚本的output应该存放到什么位置。 let out_dir = env::var_os("OUT_DIR").unwrap(); let dest_path = Path::new(&out_dir).join(""); fs::write( &dest_path, "pub fn message() -> &'static str { \"Hello, World!\" } " ).unwrap(); //注意哟：这不是普通的print呀， 这是配置cargo的一种官方方法。 //“rerun-if-changed”是cargo 指令，下面代码的意思是：只有当脚本文件发生变化时，才重新执行， //否则默认只要package里的文件发生变化，就re-run 。 println!("cargo:rerun-if-changed="); }
//src/ //关键点：此行宏代码将生成的代码文件包含进来加入编译。 include!(concat!(env!("OUT_DIR"), "/")); fn main() { println!("{}", message()); }
(7) 条件编译
Rust属性cfg 、 cfg_attr 和宏cfg! 是实现条件编译的三剑客，再配合上构建预处理脚本， 四驾马车并行不悖，从而实现Rust条件编译。详情请看：`/reference/`、
`/reference/#the-cfg-attribute`、`/std/`、实际的代码例子：`/sfackler/rust-openssl/blob/dc72a8e2c429e46c275e528b61a733a66e7877fc/openssl-sys/build/#L216`
【cfg 属性】
// cfg(predicate)， 这个predicate中文意思为：谓词， 说白了就是一些判断表达式， 最终结果为true/false //而且predicate间可以通过all, any , not 组合起来， 表达与、或、非, 用于条件组合。 //所以下面的函数只在"macos"系统下才会被加入编译。 #[cfg(target_os = "macos")] fn macos_only() { // ... } //any相当于或的关系， 所以只要foo或者bar只要有一个被定义了， 则结果为true, 即下面的函数就会被加入编译。 //提示一下！！！通常我们在构建脚本中检测系统环境， 从而决定定义foo还是bar。 #[cfg(any(foo, bar))] fn needs_foo_or_bar() { // ... } //all相当于与的关系， 所有条件都为true时，最终结果才为true。所以下面的意思为：首先必须是unix 系统并且必须是32bit环境，所有条件都同时满足时下面函数才被加入编译。 #[cfg(all(unix, target_pointer_width = "32"))] fn on_32bit_unix() { // ... } //not 相当于非的关系，取反的关系。 //如果定义了foo, 则下面函数不被加入编译， 反之加入。 #[cfg(not(foo))] fn needs_not_foo() { // ... }
【cfg_attr 属性】
//例子1 #[cfg_attr(linux, path = "")] //当linux被预定义时， 谓词为真 ， 故此cfg_attr展开为：#[path = ""] #[cfg_attr(windows, path = "")] //当windows被预定义时， 谓词为真 ， 故此cfg_attr展开为：#[path = ""] mod os; //例子2 #[cfg_attr(feature = "magic", sparkles, crackles)] //当谓词：feature = "magic"为真时， cfg_attr才会展开为如下： #[sparkles] #[crackles] fn bewitched() {} //总结： cfg 主攻条件判断， cfg_attr主攻条件满足后自动展开， 前者主要在于条件编译， 后者主要在于按条件配置不同属性， 两者共同适合那些可以配置属性的rust 元素， 如函数， trait, struct, enum等等， //而宏cfg! 适合用在函数代码逻辑中，if cfg!(predicate) some code else other code ，如下例： let machine_kind = if cfg!(unix) { "unix" } else if cfg!(windows) { "windows" } else { "unknown" }; println!("I'm running on a {} machine!", machine_kind);
【cargo feature】
[package] name = "conditional_compilation" version = "0.1.0" authors = ["yujinliang <285779289@>"] edition = "2018" build="" # See more keys and their definitions at /cargo/reference/ [features] default = ["foo_1"] # cargo build /run 默认开启的feature。 foo_1 = [] #定义一个feature。 foo_2 = [] foo_3 = [] # 方括号中列出此feature依赖的其他feature， 逗号分割。 #cargo build/run --features "foo_2" #cargo build/run #默认开启default feature #cargo run --features "foo_2 foo_3" #开启编译foo_2 和foo_3 feature。 [dependencies]
//src/ #[cfg(feature = "foo_1")] fn foo_1() { println!("foo_1"); } #[cfg(feature = "foo_2")] fn foo_2() { println!("foo_2"); } #[cfg(feature = "foo_3")] fn foo_3() { println!("foo_3"); } fn foo() { if cfg!(feature = "foo_1") { println!("foo_1"); } if cfg!(feature = "foo_2") { println!("foo_2"); } if cfg!(feature = "foo_3") { println!("foo_3"); } } fn main() { foo(); }
构建编译时， 可以选择不同的feature, 从而选择组合不同的功能子集， 非常灵活有效， 详情请看：`/cargo/reference/` 和`/questions/27632660/how-do-i-use-conditional-compilation-with-cfg-and-cargo` , `/crates/cfg-if`
通常我们的工程引用其他creates时， 可以指定启用其那些features, 如下：
[dependencies] serde = {version = "1.0", default-features = false} #不启用默认features [dev-dependencies] serde = {version = "1.0", features = ["std"]} #既然是中括号当然是个列表，逗号分割，代表可以启用许多features.
- 回调函数
C语言的函数指针大家应该都了解，我不再啰嗦！一旦跨越C和Rust的语言边界， 大家都遵循C ABI世界语互通， 故此回调函数只能采用C语言的函数指针， 而Rust闭包实则为Rust语法糖，只有Rust自己认得！
采用Rust闭包当做回调函数非常简洁高效易用， 但是C不认识它！为此网上一位高手介绍了一种方法，通过C函数指针、Rust泛型、Rust闭包等，最终间接实现了采用Rust闭包作为回调函数的方法，原文链接：
`/posts/rust-closures-in-ffi/` ， 有兴趣大家可以看看， 我自己也参照其原文整理出了两个代码例子，代码地址：`/yujinliang/rust_learn/tree/master/unsafe_collect/ffi/c2rust/closure_as_callback` ， `/yujinliang/rust_learn/tree/master/unsafe_collect/ffi/c2rust/simple`
- 交叉编译
这是一个复杂庞大的主题， 我不主攻这方面，所以不再班门弄斧，收集一些好资料简单学习一下，以后有精力再深入学习， Rust 交叉编译好资料： /japaric/rust-cross , /cross-compile-libcore/ , 交叉编译工具：/rust-embedded/cross , /japaric/xargo ， /release/ ，/freestanding-rust-binary/
嵌入式开发分为两大类， 如下：
【Bare Metal Environments裸机硬件】
没有操作系统， 程序直接运行在裸机中， #![no_std] is a crate-level attribute that indicates that the crate will link to the core-crate instead of the std-crate.
`/core/` , `/std/` ， 说白了不能使用rust std, 只能使用其微缩版rust-libcore , 一个no_std小例子：/embedonomicon/ ，
【Hosted Environments有操作系统】
硬件上有操作系统， 如：linux /windows/macos/ios ， rust 程序可以引用rust std, 可以理解为我们通常使用的PC环境，或者可以运行操作系统的环境。
- 关于作者：
作者：心尘了
email: 285779289@
git：/yujinliang
**** ID：htyu_0203_39
知乎: /people/xin-chen-liao
智商尚可，情商归零，早年入行，不善文章，埋头码农， 而今不惑之年，多年风雨， 恍然而过，志在何方？！我斗胆喊他几嗓子， 好不好，对不对， 您就权当一乐！
我就是想告诉这世界， 我来过！
- 参考资料：
/questions/24145823/how-do-i-convert-a-c-string-into-a-rust-string-and-back-via-ffi
/nomicon/
/rust-ffi-guide/
/rust-ffi-omnibus/
/book/interoperability/
/verkkokauppacom/creating-an-ffi-compatible-c-abi-library-in-rust-5dji
/std/ffi/
/en/
/alexcrichton/rust-ffi-examples
/posts/rust-closures-in-ffi/
/Michael-F-Bryan/rust-closures-and-ffi
/mystor/rust-cpp
/c-programming/static-and-dynamic-linking-in-c
/questions/40833078/how-do-i-specify-the-linker-path-in-rust
/cargo/reference/
/reference/#the-cfg-attribute
/std/
/sfackler/rust-openssl/blob/dc72a8e2c429e46c275e528b61a733a66e7877fc/openssl-sys/build/#L216
/reference/
/cargo/reference/#rustc-cfg
/questions/27632660/how-do-i-use-conditional-compilation-with-cfg-and-cargo
/cargo/reference/
/rust-lang/rust-bindgen
/eqrion/cbindgen
/post/2019-05-15-rust/
《深入浅出Rust》范长春著， 机械工业出版社
/crates/cpp
/crates/cpp_build
/2020/05/15/
/2020/01/30/Rust-1.41.
/book/interoperability/
/question/22940048
/questions/43826572/where-should-i-place-a-static-library-so-i-can-link-it-with-a-rust-program
/std/panic/fn.catch_unwind.html
/programming/2018/11/18/
/questions/37526598/how-can-i-override-a-constant-via-a-compiler-option
/cargo/reference/
/reference/
/japaric/rust-cross
/compiler/cross-compilation/
/rust-embedded/cross
/cross-compile-libcore/
/book/intro/
/japaric/xargo
/embedonomicon/
/release/
/freestanding-rust-binary/
/en/
/lbd/
/lbd/
/ilo5u/CX-CPU
/jspui/bitstream/handle/123456789/345/;sequence=1
/lbt/
/docs/
/c64scene-ar/llvm-6502
/images/b/b7/
/earl1k/llvm-z80
/openrisc/llvm-or1k
/lbd/