Rust FFI与C交互:跨语言编程实践

Rust与FFI:构建多语言编程的桥梁 Rust与FFI:多语言编程的桥梁。Rust通过FFI与其他语言交互,例如与C语言和JavaScript。Rust可以作为中间层,允许不同语言之间的通信。在实际应用中,我们需要深入理解Rust的FFI机制,并确保在与其他语言交互时保持安全性。 阅读详情

Rust FFI与C交互:跨语言编程实践

引言

大家好,我是一名正在从Rust转向Python的后端开发者。在实际项目中,我们经常需要与其他语言进行交互,特别是C语言。Rust提供了强大的FFI(Foreign Function Interface)支持,可以方便地与C代码进行互操作。今天,我想和大家分享一下我在Rust FFI编程方面的经验。

FFI基础

什么是FFI?

FFI是一种机制,允许不同编程语言之间相互调用。Rust的FFI主要用于:

  1. 调用C库
  2. 被其他语言调用
  3. 与系统API交互

基本概念

// 外部函数声明
extern "C" {
    fn printf(format: *const i8, ...) -> i32;
}

fn main() {
    unsafe {
        printf("Hello from C!\n\0".as_ptr());
    }
}

调用C函数

简单示例

use std::os::raw::c_int;

extern "C" {
    fn abs(x: c_int) -> c_int;
}

fn main() {
    unsafe {
        let result = abs(-42);
        println!("abs(-42) = {}", result); // 42
    }
}

传递字符串

use std::os::raw::c_char;
use std::ffi::CString;

extern "C" {
    fn puts(s: *const c_char) -> c_int;
}

fn main() {
    let c_str = CString::new("Hello from Rust!").unwrap();
    
    unsafe {
        puts(c_str.as_ptr());
    }
}

传递数组

use std::os::raw::{c_int, c_float};

extern "C" {
    fn process_array(arr: *const c_float, len: c_int);
}

fn main() {
    let arr = [1.0f32, 2.0f32, 3.0f32, 4.0f32, 5.0f32];
    
    unsafe {
        process_array(arr.as_ptr(), arr.len() as c_int);
    }
}

导出Rust函数给C

基本示例

#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[no_mangle]
pub extern "C" fn greet(name: *const u8) {
    let name_str = unsafe {
        std::ffi::CStr::from_ptr(name as *const i8).to_str().unwrap()
    };
    println!("Hello, {}!", name_str);
}

导出结构体

#[repr(C)]
pub struct Point {
    x: f64,
    y: f64,
}

#[no_mangle]
pub extern "C" fn create_point(x: f64, y: f64) -> Point {
    Point { x, y }
}

#[no_mangle]
pub extern "C" fn distance(p1: Point, p2: Point) -> f64 {
    ((p1.x - p2.x).powi(2) + (p1.y - p2.y).powi(2)).sqrt()
}

内存管理

分配和释放内存

use std::ffi::CString;
use std::os::raw::c_char;

#[no_mangle]
pub extern "C" fn create_string() -> *mut c_char {
    let s = CString::new("Hello from Rust").unwrap();
    s.into_raw()
}

#[no_mangle]
pub extern "C" fn free_string(s: *mut c_char) {
    unsafe {
        if !s.is_null() {
            let _ = CString::from_raw(s);
        }
    }
}

使用libc分配器

use libc::{malloc, free, c_void};
use std::ptr;

fn main() {
    unsafe {
        let ptr = malloc(1024) as *mut i32;
        if !ptr.is_null() {
            *ptr = 42;
            println!("Value: {}", *ptr);
            free(ptr as *mut c_void);
        }
    }
}

实际应用场景

场景1:封装C库

use std::ffi::CString;
use std::os::raw::c_char;

extern "C" {
    fn sqlite3_open(filename: *const c_char, db: *mut *mut sqlite3) -> c_int;
    fn sqlite3_close(db: *mut sqlite3) -> c_int;
}

struct SqliteDb {
    db: *mut sqlite3,
}

impl SqliteDb {
    fn open(filename: &str) -> Result<Self, String> {
        let c_filename = CString::new(filename).map_err(|e| e.to_string())?;
        let mut db: *mut sqlite3 = ptr::null_mut();
        
        let result = unsafe { sqlite3_open(c_filename.as_ptr(), &mut db) };
        
        if result != 0 || db.is_null() {
            return Err("Failed to open database".to_string());
        }
        
        Ok(Self { db })
    }
}

impl Drop for SqliteDb {
    fn drop(&mut self) {
        if !self.db.is_null() {
            unsafe { sqlite3_close(self.db) };
        }
    }
}

场景2:高性能计算库

use std::os::raw::c_float;

#[no_mangle]
pub extern "C" fn matrix_multiply(
    a: *const c_float,
    b: *const c_float,
    result: *mut c_float,
    n: usize,
) {
    unsafe {
        for i in 0..n {
            for j in 0..n {
                let mut sum = 0.0f32;
                for k in 0..n {
                    sum += *a.add(i * n + k) * *b.add(k * n + j);
                }
                *result.add(i * n + j) = sum;
            }
        }
    }
}

场景3:回调函数

use std::os::raw::{c_int, c_char};
use std::ffi::CStr;

type Callback = extern "C" fn(c_int, *const c_char);

extern "C" fn process_items(callback: Callback) {
    let items = [1, 2, 3, 4, 5];
    
    for (i, &item) in items.iter().enumerate() {
        let msg = format!("Item {}", item);
        let c_msg = std::ffi::CString::new(msg).unwrap();
        callback(i as c_int, c_msg.as_ptr());
    }
}

构建静态库和动态库

静态库

[lib]
name = "mylib"
crate-type = ["staticlib"]
cargo build --release

动态库

[lib]
name = "mylib"
crate-type = ["cdylib"]
cargo build --release

实战项目:Rust日志库供C使用

use std::ffi::CStr;
use std::os::raw::c_char;

#[repr(C)]
pub enum LogLevel {
    Debug,
    Info,
    Warning,
    Error,
}

#[no_mangle]
pub extern "C" fn rust_log(level: LogLevel, message: *const c_char) {
    let message_str = unsafe {
        CStr::from_ptr(message).to_str().unwrap_or("Invalid string")
    };
    
    match level {
        LogLevel::Debug => println!("[DEBUG] {}", message_str),
        LogLevel::Info => println!("[INFO] {}", message_str),
        LogLevel::Warning => println!("[WARN] {}", message_str),
        LogLevel::Error => eprintln!("[ERROR] {}", message_str),
    }
}

#[no_mangle]
pub extern "C" fn rust_log_fmt(level: LogLevel, format: *const c_char, ...) {
    use std::ffi::CString;
    use std::fmt::Write;
    
    let format_str = unsafe {
        CStr::from_ptr(format).to_str().unwrap_or("Invalid format")
    };
    
    let mut message = String::new();
    let _ = write!(message, "{}", format_str);
    
    rust_log(level, CString::new(message).unwrap().as_ptr());
}

与Python C扩展的对比

特性Rust FFIPython C扩展
内存安全编译时保证手动管理
类型安全编译时检查运行时检查
性能零开销有一定开销
互操作性与C无缝与C无缝
学习曲线较陡峭相对简单

总结

Rust的FFI系统提供了强大的跨语言交互能力:

  1. 调用C库:可以轻松调用现有的C库
  2. 导出函数:可以将Rust函数导出给C使用
  3. 内存管理:需要谨慎处理内存分配和释放
  4. 性能:零运行时开销,性能优异

通过合理使用FFI,我们可以:

  • 复用现有的C代码
  • 为其他语言提供高性能的Rust库
  • 与系统API进行交互

作为从Rust转向Python的开发者,我发现Rust的FFI系统比Python的C扩展更加安全和高效。虽然需要注意内存管理,但类型安全带来的好处是巨大的。


延伸阅读:

Rust与C/C++互操作实战:构建高效、安全的跨语言系统 Rust与C/C++的互操作使得开发者能够将Rust的内存安全性和现代化特性引入到传统的C/C++项目中。通过FFI和外部接口,我们可以在保留C/C++性能优势的同时,享受Rust的安全性和易用性。无论是需要逐步迁移的旧项目,还是全新的跨语言系统,Rust与C/C++的互操作性都提供了强有力的支持。希望通过本文,你能更好地理解Rust与C/C++的互操作方式,并在实践中应用这些技巧,构建更加高效和安全的跨语言系统。 阅读详情

相关推荐

12、Rust FFI:跨语言交互的桥梁

本文深入探讨了 Rust 中的 FFI(Foreign Function Interface)技术,介绍了如何通过 `extern` 关键字实现 Rust 与 C/C++ 等语言的互操作性。内容涵盖 FFI 的基本概念、调用 C 函数、处理复杂数据类型、内存管理、错误处理以及最佳实践,强调在跨语言交互中保持 Rust 的内存安全特性。同时,文章还讲解了如何向其他语言暴露 Rust 代码,并讨论了在 FFI 中确保线程安全和编写健壮、可维护 FFI 代码的实用技巧。

e6f7g8h9i的博客 194

Rust的#[repr(C)]与FFI结构体布局在跨语言互操作中的精确控制

[repr(C)]不仅保证字段顺序,还允许开发者通过#[repr(align(N))]或#[repr(packed)]进一步控制对齐和压缩。Rust的#[derive(Debug)]等派生宏可与#[repr(C)]共存,方便调试而不影响布局。Rust作为一门注重安全与性能的语言,提供了#[repr(C)]属性,用于精确控制结构体在内存中的布局,确保与其他语言(如C/C++)的无缝交互。#[repr(C)]同样适用于嵌套场景,例如Rust结构体包含另一个#[repr(C)]结构体或C风格的枚举。

kxoekg_803的博客 178

ENVI5.6 自动化流程:GF系列卫星影像批处理与质量优化

本文详细介绍了如何利用ENVI5.6构建针对GF-2、GF-6、GF-7系列卫星影像的自动化批处理流水线。通过配置Batch Processing工具,实现从正射校正到图像融合的全流程批量处理,并分享参数设置、质量监控与故障排查的实战经验,旨在显著提升海量遥感影像的处理效率与成果质量。

efc1234567的博客 605

Rust的#[repr(C)]中的对齐网络

在系统编程领域,内存布局的精确控制至关重要。Rust作为一门注重安全与性能的语言,提供了#[repr(C)]属性,允许开发者按照C语言的规则安排结构体的内存对齐方式。本文将深入探讨#[repr(C)]中的对齐网络,揭示其背后的机制与实际应用价值。#[repr(C)]允许开发者结合#[repr(align(N))]进一步定制对齐方式,例如将结构体强制对齐到缓存行(通常64字节)以减少伪共享。现代CPU对对齐数据的加载效率更高,而#[repr(C)]通过强制对齐,避免了编译器因布局优化而引入的潜在性能损失。

lahvxn_372的博客 189

如何浏览与下载全球免费的地图高分辨率(亚米级)的遥感影像?

前言 如果你想使用商业卫星的高分辨遥感影像,一般价格昂贵。我们可以使用地图平台上免费的高分辨率数据。目前数据源很多,比如说google earth、天地图、四维地球、必应地图等等。这些影像统一有一个共同点就是:RGB三波段;Web地图瓦片服务。这意味着我们可以通过瓦片服务下载影像,但下载的影像只有三个波段,分别是 一.引言 二、可使用高分辨率的地图数据源 1.Google Earth影像 2.Esri World Image 3.天地图 4.必...

锐多宝的地理空间 2万+

Transformers在自动驾驶领域的应用(High-level like in scene)

Transformers uses global attention mechanism to capture long-range interaction information. Two core modules in Transformers are Self-Attention and Cross-Attention, which defined asAttn(Q,K,V)=softmax(QK⊤dk)VSelfAttn(X)=Attn(WQX,WKX,WVX)CrossAttn(X,Y)=Attn

qq_39337332的博客 1776

Rust FFI编程:与C/C++及其他语言的无缝集成

你是否曾想在Rust项目中复用现有的C/C++库,或者需要让Rust代码被其他语言调用?Rust的FFI(Foreign Function Interface,外部函数接口)功能让这一切变得简单。本文将带你一步步掌握Rust与C/C++及其他语言的无缝集成,解决跨语言调用的痛点问题。读完本文,你将能够: - 理解Rust FFI的基本概念和工作原理 - 掌握Rust与C语言之间的数据类型转换 -...

gitblog_00836的博客 1274

解密m3u8视频合并:从猫抓插件到本地文件修改全流程

本文详细解析了m3u8视频合并的全流程,特别针对加密视频片段提供了解决方案。从使用猫抓插件捕获m3u8文件地址,到利用N_m3u8DL-CLI工具自动下载、解密并合并ts片段,手把手教你处理AES-128加密等常见问题,最终生成完整的本地MP4文件,适合需要备份或处理流媒体资源的用户。

weixin_29290947的博客 1369

Karakeep(原 Hoarder)架构解析:Web 应用 + SQLite 队列 + 三类 Worker 的协作模型

Karakeep 是一款可自托管的"收藏一切"应用(链接、笔记与图片均可收藏),其核心架构用一个简单而清晰的模型支撑起完整的收藏流水线:**Web 应用负责用户交互与数据存储,后台 Worker 负责抓取、AI 标注与索引**。本文以官方架构文档为主体,结合仓库源码逐步拆解这套架构:Web 层为何选择 Next.js + SQLite,任务队列如何在 SQLite 之上运转,以及 Crawling

gitblog_00626的博客 1181

YOLO11实战 第001期-基于yolo11的CrowdHuman密集行人目标检测实战文档(yolo格式数据免费获取)

1.数据阶段在拥挤/遮挡场景下,使用crowdhuman数据集重训练后的yolo11,效果表现较好。crowdhuman数据集标签如下,有Head BBox、Visible BBox、Full BBox。如下图显示:数据集介绍CrowdHuman数据集是旷世发布的用于行人检测的数据集,图片数据大多来自于google搜索。CrowdHuman数据集数据量比较大,15000张,5000张,验证集4370张。训练集和验证集中共有470K个实例,约每张图片包含23个人,同时存在各种各样的遮挡。

深度学习算法工程师,专注于前沿算法研究与实战应用。在这里,我将分享深度学习领域的实战经验、优质数据集资源以及最新论文解读与精度分析,旨在与广大技术爱好者共同探索人工智能的奥秘,助力技术成长与创新。 2168

WblockCloneObjects克隆一个图纸内的实体包括块参照,同名块参照的处理

public static void HeBingTu2(double lieJu, List<string> filePaths) { Document doc = Application.DocumentManager.MdiActiveDocument; Database db = doc.Database; using (DocumentLock docLock = doc.Lock...

1108

Rust FFI 编程 - FFI 概述

FFI(Foreign Function Interface)是这样一种机制:用一种编程语言写的程序能调用另一种编程语言写的函数(routines)。FFI 有两种内涵。一种是是在当前...

Rust语言学习交流 6729

【C语言】一文带你拿捏分支和循环语句(一万字详细讲解)

if/switch语句、while/fo/do...while循环语句、goto语句详解

StackFrame 1237

Rust通过FFI调用C函数实战指南

Rust通过FFI机制无缝调用C函数,支持标准库函数、自定义C库及结构体指针等复杂交互。本文基于Ubuntu 22.04环境,详细演示了Rust调用C函数的三种典型场景:直接调用strlen等标准库函数;通过cc工具链编译并链接自定义C函数;使用bindgen自动生成复杂结构体的Rust绑定代码。实践表明,Rust的FFI功能强大且灵活,能有效复用现有C代码资源,同时保持Rust的安全特性,为混合编程提供了可靠解决方案。

科技改变人类,技术成就未来 2万+

YOLOv8 交通违规检测各个场景的实际应用

本文介绍了基于YOLOv8的交通违规检测系统在不同场景下的应用实现。系统可检测闯红灯、超速、违停和不系安全带等多种违规行为,针对每种场景提供了具体的技术方案和Python实现代码。其中闯红灯检测结合信号灯状态分析,超速检测通过距离时间计算速度,违停检测采用长时间跟踪策略,安全带检测则需更高精度识别。文章还展示了如何整合各功能构建综合交通监管系统,并总结了不同应用场景的技术要点和优化方向,为智能交通管理提供了实用解决方案。

u010117029的博客 301

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Rust中FFI编程知识点整理总结

这个工具就是将写好的Rust代码配置一下,然后会自动生成接口代码头文件等等。其实,FFI封装、转换,熟悉了之后,知识点就那些,模式也比较固定,如果接口量很大,那就需要大量重复的 coding。量一大,人手动绑定出错的机率也大。所以这种辅助工具的意义就显露出来了。基于辅助工具生成的代码,如不完美,再适当手动修一修,几下就能搞定,大大提高生产效率。

phthon1997的博客 2101

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

深入 Rust 外部函数接口:C ABI 稳定性、结构体布局与跨语言异常传播

[repr(C)]是 Rust FFI 结构体布局正确性的保证。它强制字段按声明顺序排列并使用 C 兼容的对齐规则。编译期静态断言(N] = [();)能在编译时捕获布局不匹配。优于运行时崩溃。是防止 Rust panic 跨 C 栈帧传播的唯一安全手段。所有传入 C 的回调函数必须包裹。Rust 分配的内存必须由 Rust 释放。使用匹配的 allocator。暴露释放函数给 C 侧是跨语言内存管理的标准做法。优先使用已有的 Rust 封装库(libc/nix/bindgen 生成)。

2301_81410839的博客 4641

假人有限元模型

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

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Rust与C的FFI示例项目指南

Rust与C#的FFI示例项目指南 本指南将详细介绍如何理解和操作GitHub上的开源项目KodrAus/rust-csharp-ffi,该项目展示了如何在Rust和C#之间通过FFI(Foreign Function Interface)进行交互。我们将分为三个主要部分进行探索:项目的目录结构、启动文件以及配置文件。 1. 项目的目录结构及介绍 项目整体架构: 本项目采用典型的双语言结构,包含R...

gitblog_00795的博客 1071

Rust FFI 实践

背景 部门算法团队开始成长起来,开始有越来越多的尝试以及成果,但是现在工程方面严重的限制了(主要是做预测服务)他们的研究成果转化为实际输出的能力。去年下半年,我们就发现TF官方的Java binding 存在严重的内存泄露问题,而TF Java binding 因为封装包括训练和预测所需要的API,比较复杂,我们也难以更改。同时,使用TF serving,...

allwefantasy的专栏 2950

【C 语言与 Rust FFI 开发终极指南】:掌握跨语言调用的核心技术与最佳实践

掌握C 语言与 Rust 的 FFI 接口开发核心技术,解决跨语言调用难题。涵盖接口设计、内存安全处理与性能优化,适用于系统集成与混合编程场景。提供清晰示例与最佳实践,助你高效构建稳定互操作应用,值得收藏。

FastCompile的博客 661

Rust 与 C/C++ 互操作:FFI 的实践与技巧

Rust通过外部函数接口(FFI)实现与C/C++代码的高效互操作。FFI允许Rust调用C/C++函数并共享数据结构,借助extern "C"声明、裸指针(*const T/*mut T)和#[repr(C)]属性确保兼容性。Rust的Vec和String可分别转换为C数组和字符串,配合unsafe块进行安全解引用。工具链方面,build.rs用于编译C库,bindgen自动生成Rust绑定。这种机制使Rust能复用现有C/C++代码库,同时逐步迁移到Rust的安全模型中。

2501_93870138的博客 828

Rust与Go跨语言编程终极指南:如何实现高性能FFI调用

想要在Go项目中调用Rust的高性能代码吗?😊 Rust+Go跨语言编程通过FFI技术让这两个强大的编程语言完美协作。本文将为你详细介绍如何实现Rust与Go的无缝集成,让你轻松驾驭跨语言编程的魔力!🚀 ## 为什么选择Rust+Go组合? Rust以其内存安全和零成本抽象著称,而Go则以简洁的并发模型和高效的开发体验闻名。通过FFI调用,你可以: - 在Go项目中利用Rust的高性能计

gitblog_00541的博客 998

Rust跨语言调用FFI外部函数接口

1. 背景知识 FFI(Foreign Function Interface)外部函数接口:用于规范语言间调用的语言特征。 FFI技术的主要功能是: 将一种编程语言的语义和调用约定与另一种编程语言的语义和调用约定相匹配。 所谓匹配是指: 不管哪种编程语言,无论是编译执行还是解释执行,最终都会到达处理器指令环节,在该环节,编程语言之间的语法、数据类型等语义差异均已消除,只需匹配调用约定即可,从而可以实现不同编程语言之间的相互调用。 匹配调用约定,需要用到应用程序二进制接口(ABI)。 何为ABI?ABI是一个

mutourend2010@gmail.com 3547

【Rust 基础篇】Rust FFI:连接Rust与其他编程语言的桥梁

FFI是"Foreign Function Interface"的缩写,意为外部函数接口。在编程中,FFI是一种机制,用于在不同的编程语言之间进行交互。Rust的FFI允许Rust代码调用其他编程语言的函数,也允许其他编程语言调用Rust的函数。通过FFI,我们可以实现Rust与其他编程语言之间的无缝集成,从而充分发挥各种编程语言的优势。在Rust中,实现FFI的主要方式是使用extern关键字。extern关键字用于声明外部函数,告诉Rust编译器这是一个外部函数,而不是Rust自己的函数。

繁依Fanyi的博客 2152

Rust FFI实战指南:轻松实现与C库的跨语言交互

Rust FFI(Foreign Function Interface)是连接Rust与其他编程语言的桥梁,尤其在与C语言库交互时表现出色。本文将以简单易懂的方式,带你掌握Rust FFI的核心概念和实用技巧,让跨语言开发不再复杂。 ## 为什么选择Rust FFI? Rust凭借其内存安全和高性能特性,成为系统级编程的理想选择。而通过FFI,我们可以: - 复用成熟的C语言库,避免重复造轮子

gitblog_00115的博客 404

Rust编码规范中文版:FFI与系统编程的安全编码规范

Rust编码规范中文版是一份非官方的Rust安全编码指南,特别关注FFI(外部函数调用接口)与系统编程领域的安全实践。本文将深入解析Rust与C语言交互时的核心安全规范,帮助开发者避免常见的内存安全问题和跨语言调用风险。 [![Rust编码规范应用领域](https://raw.gitcode.com/gh_mirrors/ru/rust-coding-guidelines-zh/raw/6b3

gitblog_00573的博客 845
上一篇: Python 正则表达式实战:从入门到精通
下一篇: Python 日志系统设计:构建可观测的应用
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值