• 外部语言函数接口

    外部语言函数接口

    Rust 提供了外部语言函数接口（Foreign Function Interface，FFI）到 C 语言库。外部语言函数必须声明在一个 extern 代码块，且该代码块要带有一个包含外部语言库名称的 #[link] 属性。

    1. use std::fmt;
    3. // 此外部代码块链接到 libm 库
    4. #[link(name = "m")]
    5. extern {
    6.     // 这是外部语言函数
    7.     // 这计算了一个单精度复数的平方根
    8.     fn csqrtf(z: Complex) -> Complex;
    9. }
    11. fn main() {
    12.     // z = -1 + 0i
    13.     let z = Complex { re: -1., im: 0. };
    15.     // 调用一个外部语言函数是一种不安全的操作
    16.     let z_sqrt = unsafe {
    17.         csqrtf(z)
    18.     };
    20.     println!("the square root of {:?} is {:?}", z, z_sqrt);
    21. }
    23. // 最小化实现单精度复数
    24. #[repr(C)]
    25. #[derive(Clone, Copy)]
    26. struct Complex {
    27.     re: f32,
    28.     im: f32,
    29. }
    31. impl fmt::Debug for Complex {
    32.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    33.         if self.im < 0. {
    34.             write!(f, "{}-{}i", self.re, -self.im)
    35.         } else {
    36.             write!(f, "{}+{}i", self.re, self.im)
    37.         }
    38.     }
    39. }

    由于调用外部语言函数通常被认为是不安全的，因此围绕它们编写安全的装包代码是相当普遍的。

    1. use std::fmt;
    3. #[link(name = "m")]
    4. extern {
    5.     fn ccosf(z: Complex) -> Complex;
    6. }
    8. // 安全装包（原文：safe wrapper）
    9. fn cos(z: Complex) -> Complex {
    10.     unsafe { ccosf(z) }
    11. }
    13. fn main() {
    14.     // z = 0 + 1i
    15.     let z = Complex { re: 0., im: 1. };
    17.     println!("cos({:?}) = {:?}", z, cos(z));
    18. }
    20. // 最小化实现单精度复数
    21. #[repr(C)]
    22. #[derive(Clone, Copy)]
    23. struct Complex {
    24.     re: f32,
    25.     im: f32,
    26. }
    28. impl fmt::Debug for Complex {
    29.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    30.         if self.im < 0. {
    31.             write!(f, "{}-{}i", self.re, -self.im)
    32.         } else {
    33.             write!(f, "{}+{}i", self.re, self.im)
    34.         }
    35.     }
    36. }