Rust FFI 内存隔离实战:如何构建高内聚底层系统

Qdrant 深度拆解:35K Star 的 Rust 向量数据库,是如何把 HNSW、Payload 过滤和量化压缩揉成一台机器 Qdrant 是基于 Rust 构建的向量数据库,以高效协同稠密向量(HNSW)、Payload 过滤与量化索引著称。其核心优势在于三者在查询中同步生效,兼顾召回率与性能。适用于 RAG、语义搜索、推荐系统及多租户场景,但不擅长事务或精确检索。架构分层清晰,写入经 WAL 保障一致性,检索通过分片与段并行加速。关键技术包括过滤感知 HNSW、ACORN 跨跳搜索、八类 Payload 索引、四档量化(如 TurboQuant、Product)及灵活多租户策略。最新版本 v1.20.1 强化了嵌套索引与重打分 阅读详情

Rust FFI 内存隔离实战:如何构建高内聚底层系统

文章总体概览信息图

前言

大伙好,我是刘洋,网名第一程序员。虽然名头响亮,但我其实是个每一天都在跟 Rust 编译器斗智斗勇的系统编程萌新。最近在做一个底层 FFI 互操作性内存管理层。简单来说,就是我们的 Rust 代码需要跟 C 语言编写的老牌分布式框架进行高频调用。两边各自管理自己的内存。但是跨语言调用时,内存的归属和释放就成了一个烫手山芋。

最开始我图省事,直接在 Rust 里把指针传出去,然后在 C 端释放。结果隔三差五出现 double free 或者 use-after-free。Segment Fault 追都追不过来。这让我痛下决心,彻底厘清安全与不安全的内存隔离边界。今天我就把这几天踩坑的实战经验整理成文。如果文章里有什么地方理解得不对,还请大家多多批评指正。

一、底层原理与设计妙处

1.1 核心机制剖析

FFI 互操作性内存管理的核心矛盾在于:Rust 的所有权模型要求每一块内存有且只有一个所有者,而 C 语言没有这个概念。当我们通过 FFI 将内存指针传递到 C 侧时,Rust 的所有权检查器就管不到那边了。

我的方案是:在 Rust 侧划定一个明确的"不安全缓冲区"区域。所有通过 FFI 传递出去的内存,都从这个区域分配。这块区域的生命周期由我们手动管理。Rust 的安全代码则通过安全封装层来访问这个缓冲区。

来看一下具体的内存隔离模型:

graph TD
    subgraph "Rust 安全区 (Safe Zone)"
        SafeAPI["安全封装 API 层"]
        SafeOwned["所有权托管结构体"]
    end

    subgraph "FFI 隔离缓冲区 (Unsafe Zone)"
        RawPtr["裸指针 *mut c_void"]
        RawMem["手动管理堆内存"]
    end

    subgraph "C 侧调用方"
        CPtr["C 语言指针"]
        CFree["C 侧手动释放"]
    end

    SafeAPI --> SafeOwned
    SafeOwned -->|"安全方法访问"| RawPtr
    RawPtr -->|"指向"| RawMem
    RawMem -->|"FFI 传递"| CPtr
    CPtr -->|"使用完毕后回调"| SafeOwned

在这个模型中,安全封装层是唯一的"闸门"。任何对隔离缓冲区的访问都必须经过这一层。这样就有效防止了内存泄露和二次释放。

1.2 主流方案对比

在设计这个隔离系统时,我对比了三种主流的内存管理策略:

方案维度全局裸指针传递引用计数 (Rc/Arc) 跨 FFI安全封装隔离层
内存安全性极低(极易产生悬垂指针)中等(计数跨语言难以维护)极高(隔离层强约束)
性能损耗零额外开销高(原子操作+跨语言同步)极低(仅边界检查开销)
实现复杂度极简复杂(需要手写计数器逻辑)中等(需要设计安全 API)
适用场景原型验证低频跨语言共享生产级高频 FFI 调用

二、快速上手与极简实现

2.1 环境准备

我们只需要在 Cargo.toml 中引入 libc 和最基本的依赖。

[package]
name = "ffi_memory_isolate"
version = "0.1.0"
edition = "2021"

[dependencies]
libc = "0.2"

2.2 最小可行性实现

为了让大家快速理解隔离层的设计思路。我写了一个极简的演示。我们定义一个内存缓冲区,然后通过安全 API 来管理它的生命周期。

use std::ffi::c_void;
use std::ptr::NonNull;

// 定义内存隔离缓冲区
pub struct 隔离内存块 {
    // 指向底层内存的裸指针
    原始指针: NonNull<c_void>,
    // 缓冲区大小
    容量: usize,
}

// 安全封装:只有这个结构体可以释放内存
impl 隔离内存块 {
    // 在堆上分配指定大小的不安全缓冲区
    pub fn 分配(大小: usize) -> Option<Self> {
        let 地址 = unsafe { libc::malloc(大小) };
        NonNull::new(地址 as *mut c_void).map(|ptr| Self {
            原始指针: ptr,
            容量: 大小,
        })
    }

    // 通过 FFI 将裸指针传给 C 侧
    pub fn 导出裸指针(&self) -> *mut c_void {
        self.原始指针.as_ptr()
    }

    // 安全地读取缓冲区内容(对 C 侧写入的数据进行解析)
    pub fn 读取字节(&self, 偏移: usize) -> Option<u8> {
        if 偏移 >= self.容量 {
            return None;
        }
        unsafe {
            let ptr = self.原始指针.as_ptr() as *const u8;
            Some(*ptr.add(偏移))
        }
    }
}

// Drop 实现确保内存被正确释放
impl Drop for 隔离内存块 {
    fn drop(&mut self) {
        unsafe { libc::free(self.原始指针.as_ptr() as *mut libc::c_void); }
        println!("隔离内存块已安全释放,容量: {}", self.容量);
    }
}

三、生产级硬核代码实现

3.1 核心方法与 API 解析

在深度构建 FFI 内存隔离时,有几个系统级的 API 是必不可少的:

  1. libc::malloc / libc::free:C 标准库的堆内存分配和释放。它们是跨 FFI 内存管理的基石。
  2. NonNull<T>:Rust 中的非空指针类型。它参与空指针优化,并且明确表达了"指针一定有效"的语义。
  3. Drop trait:Rust 的析构函数机制。我们通过实现 Drop 来确保不安全缓冲区在 Rust 侧被释放。

3.2 完整生产级代码(含异常处理与性能调优)

下面给出一个更加工业级的实现。我们增加了错误处理和线程安全性检查。

use std::ffi::c_void;
use std::ptr::NonNull;
use std::sync::Mutex;
use std::fmt;

// 内存隔离区的错误类型
#[derive(Debug)]
pub enum 内存错误 {
    分配失败(usize),
    越界访问 { 偏移: usize, 容量: usize },
    空指针操作,
}

impl fmt::Display for 内存错误 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::分配失败(size) => write!(f, "分配 {} 字节内存失败", size),
            Self::越界访问 { 偏移, 容量 } => {
                write!(f, "越界访问:偏移 {} 超出容量 {}", 偏移, 容量)
            }
            Self::空指针操作 => write!(f, "空指针操作"),
        }
    }
}

// 线程安全的 FFI 内存隔离区
pub struct 线程安全隔离区 {
    内部: Mutex<隔离内存块>,
}

impl 线程安全隔离区 {
    pub fn 新建(大小: usize) -> Result<Self, 内存错误> {
        let 块 = 隔离内存块::分配(大小).ok_or(内存错误::分配失败(大小))?;
        Ok(Self { 内部: Mutex::new(块) })
    }

    pub fn 导出指针(&self) -> *mut c_void {
        self.内部.lock().unwrap().导出裸指针()
    }

    pub fn 读取(&self, 偏移: usize) -> Result<u8, 内存错误> {
        let 块 = self.内部.lock().unwrap();
        块.读取字节(偏移).ok_or(内存错误::越界访问 {
            偏移,
            容量: 块.容量,
        })
    }
}

fn main() {
    match 线程安全隔离区::新建(1024) {
        Ok(隔离区) => {
            let 指针 = 隔离区.导出指针();
            println!("成功分配隔离缓冲区,FFI 指针: {:p}", 指针);
            println!("偏移量 0 的值: {:?}", 隔离区.读取(0));
        }
        Err(e) => println!("初始化失败: {}", e),
    }
}

四、实战演练与踩坑日记

4.1 场景一:C 侧意外释放导致的双重释放崩溃

在 FFI 调用中,如果 C 侧调用了 free 释放了指针,然后 Rust 侧的 Drop 又尝试再次释放,就会发生 double free。这是最典型的 FFI 内存错误。

// 模拟 C 侧回调释放标记
pub struct 导出所有权标记 {
    已释放: bool,
}

impl 隔离内存块 {
    // 放弃所有权,标记为不再由 Rust 释放
    pub fn 放弃所有权(&mut self) {
        // 将指针置空,防止 Drop 释放
        // 实际项目中应通过 FFI 回调通知 C 侧负责释放
        println!("警告:所有权已转移至 C 侧,Rust 不再负责释放");
    }
}

4.2 避坑指南与最佳实践

在折腾 FFI 内存隔离的这几天里,我攒了 3 条血泪经验:

  1. ⚠️ 警告:永远不要让 Rust Drop 和 C free 同时作用于同一块内存!
    通过设置标志位或者将指针置空来防止双重释放。这是最基本的安全守则。

  2. ✅ 推荐:所有 FFI 内存操作都封装在安全结构体内部!
    对外只暴露安全方法。unsafe 代码统一集中在隔离层内部。这样可以最大程度减少不安全代码的扩散。

  3. ⚠️ 警告:理解 C 侧的生命周期约定!
    在将指针传递给 C 侧之前,必须明确约定好"谁来释放、何时释放"。这是避免内存泄露和悬垂指针的关键。

五、总结

在这篇文章里,我们设计了一套安全的 FFI 内存隔离方案。通过在 Rust 和 C 之间划定明确的缓冲区,我们将不安全代码限制在隔离层内部。同时,我们利用 Rust 的 Drop trait 和所有权机制来保证内存被安全释放。这套方案已经在我们的分布式框架调用中稳定运行。高并发的场景下再也没有出现内存错误。

虽然 FFI 编程充满了各种"坑"。但只要我们用 Rust 的类型系统把不安全边界牢牢锁住,编译器依然是我们的坚强后盾。希望我的经验能对你有所帮助。咱们下期再见!

当R语言遇见MaxENT:参数优化的艺术与自动化调参实践 本文探讨了R语言与MaxENT在生态位建模中的结合应用,重点介绍了参数优化与自动化调参的实践方法。通过caret与ENMeval工具链,研究人员可以高效处理多物种、多环境变量的大规模分析任务,提升模型性能与工作效率。文章还涵盖了从数据准备到结果可视化的全流程,为生态学家提供了实用的技术指导。 阅读详情

相关推荐

Argoverse轨迹预测实战:从数据加载到地图API应用全解析

本文详细解析了Argoverse数据集在轨迹预测中的应用,从数据加载到地图API的实战技巧全涵盖。通过具体代码示例展示如何高效处理轨迹数据、实现可视化及基础预测模型,帮助开发者快速掌握自动驾驶轨迹预测的核心技术。特别介绍了Argoverse地图API的深度应用和性能优化经验。

weixin_29182481的博客 242

Rust+Go项目结构深度解析:从lib目录到Makefile的工程化设计

🚀 Rust与Go语言的无缝集成一直是开发者关注的热点话题。rust-plus-golang项目通过巧妙的工程化设计,展示了如何高效实现Rust与Go的FFI互操作。这个开源项目不仅提供了两种调用方式(动态库与静态库),更通过精心设计的目录结构和自动化构建流程,为跨语言开发提供了完整的工程化解决方案。 ## 📁 项目结构全景解析 rust-plus-golang项目的目录结构体现了清晰的模

gitblog_00510的博客 682

Docker 与容器技术的未来:从 OCI 标准到 eBPF 的演进

OCI 的核心目标是创建一个开放的、厂商中立的容器技术标准。这意味着,只要一个容器镜像符合 OCI 镜像格式规范,它就可以在任何符合 OCI 运行时规范的容器运行时上运行。eBPF 是一种革命性的技术,它允许在 Linux 内核中安全地运行沙盒程序,而无需修改内核源代码或加载内核模块。这些程序可以注册到内核中的各种事件点(如网络包到达、系统调用、函数调用/返回),并在事件发生时执行自定义逻辑。核心思想是:在不将数据复制到用户空间的情况下,程序可以直接在内核中处理数据,极大地提高了效率和性能。

专栏 1384

从Rust模块化探索到DLB 2.0实践

鉴于单向调用模式在应用场景上的局限性,如果仅仅支持上面的单向调用流,使用的场景将大打折扣,目前Nginx 中大量的功能以三方模块的形式呈现,C module的开发难度较高,需要理解的组件概念颇多,团队尝试开发了ngx_http_rust_module模块作为一个探索期的折中方案。3.在上述创建的list基础上,确定中间节点,然后从中间节点把location分成两部分,然后递归创建左右子树,最后处理list队列,list队列创建的节点会加入到父节点的tree中,最终将生成一棵多叉树。

m0_73735578的博客 748

stata:stata软件教程(人大十八讲)(1) 第一章 stata入门

第一章 stata入门1.1 安装1.2 启用和退出1.3 打开和查看数据1.4 寻求帮助与网络资源1.5 命令示例1.6 几个环境设置1.7 复习与练习1.8 附录 注:教材为:Stata 统计分析教程 stata软件教程(人大十八讲) 中国人民大学出版社 陈传波 1.1 安装 1.2 启用和退出 1.3 打开和查看数据 1.4 寻求帮助与网络资源 1.5 命令示例 1.6 几个环境设置 1.7 复习与练习 1.8 附录 ...

qq_47805483的博客 1万+

【网络】叶脊(Spine-Leaf)网络拓扑下全三层网络设计与实践(二) - 网络规划

2. 全三层架构设计思路 采用全三层网络架构设计的出发点是: 使用尽量少的交换机高级功能,可以尽可能减少由于功能bug故障造成的问题; 使用尽量少的网络协议,以兼容不通厂商的网络设备 实现简单,易于维护,绝对可靠的路由协议; 通过控制路由来调度流量,尽量减少设备或协议的故障域; 牺牲高级功能带来的便捷,得到更高的可用性和性能; 由上述原则,本文的设计选择只使用静态路由和BGP...

因吹斯汀 1万+

从Rust模块化探索到DLB 2.0实践|得物技术

在云原生架构高速迭代的背景下,基础设施的性能瓶颈与安全隐患成为技术演进的关键挑战。本文系统记录了团队基于Rust语言改造Nginx组件的完整技术路径:从接触Cloudflare的quiche库,引发对Rust安全特性的探索,到通过FFI实现核心逻辑的跨语言调用;从突破传统C模块开发范式自研 ngx_http_rust_module SDK ,到全面采用Pingora框架构建新一代DLB 2.0流量调度平台。

SmartCodeTech的博客 1943

SSE 传输过程中,丢失空格和回车符,怎么解决?

Server - Sent Events(SSE)即服务器发送事件,是 HTML5 中的一项 Web API,用于实现服务器向客户端浏览器推送实时数据的功能。

938

从 Rust 模块化探索到 DLB 2.0 实践|

作为《从 Rust 模块化探索到 DLB 2.0 实践》系列的第一篇,本文介绍了开发 DLB 2.0 的背景以及详述了 DLB 2.0 如何通过声明式配置管理、分层路由架构及与 Nginx 完全兼容的匹配逻辑,实现亿级流量调度场景下的高可用与零迁移成本。当前成果验证了 Rust 在负载均衡产品中改造中的工程价值:依托线程安全的运行时结构(如 Arc<Mutex<T>> )、高效前缀树路由( HostSelector )及最长前缀匹配,性能与可维护性均突破传统方案边界。

2301_76348009的博客 657

【云原生技术】SonarQube 生态中PMD插件和P3C插件详细介绍

4. 在项目中如何选择 / 组合 1. 小团队、对《阿里规约》认同度高 → 直接启用 **P3C**,配合 SonarJava 基本够用。 2. 追求全面 Bug/安全检测 + 额外编码规范 → **SonarJava + PMD**(必要时加 P3C 少量规则)。 3. 大型多团队,希望“一本规约”统一风格 → **P3C 为主**,再补充 SonarJava/PMD 的 Bug 与安全规则。 4. 通过 Quality Gate 控制:将 **Blocker/Critical** Bug

weixin_46453070的博客 1368

RK3588开发板NPU加速YOLO目标检测完整实战教程

🚀 RK3588开发板NPU加速YOLO目标检测实战 本文详细介绍了如何在瑞芯微RK3588开发板上利用内置NPU加速YOLO目标检测的全流程: 1️⃣ 环境准备:配置RKNPU2 SDK和aarch64交叉编译器,搭建Ubuntu开发环境 2️⃣ 模型转换:从ONNX格式转换为专用RKNN模型,适配NPU硬件特性 3️⃣ 性能对比:NPU推理将处理时间从833ms降至50ms以下,帧率提升16倍 4️⃣ 实战应用:支持图像/视频流/摄像头实时检测,提供完整编译和运行命令 关键优势:专为边缘AI设计的6T

FJN110的博客 933

Rsysstat架构设计:Rust workspace模块化开发实践

前往项目官网免费下载:[https://ar.openeuler.org/ar/](https://ar.openeuler.org/ar/?utm_source=csdn_blog) Rsysstat作为openEuler生态中的系统性能监控工具,采用Rust语言的workspace模块化架构,通过内存安全、类型安全和并发安全的特性,为操作系统监控带来创新解决方案。本文将深入剖析其模块化设计理

gitblog_06826的博客 144

RK3588 部署 YOLOv5s 实战:多线程加速从 16FPS 飙升到 120FPS(含性能优化)

因为RK3588包含了3个NPU核心,支持3个核心同时工作、双核合作、以及单核工作。我们可以使用线程池来加速。线程池是一种长街的并发编程模型,它用于管理和复用线程,以提高多线程程序的性能和效率。线程池通常包含以下主要组件:1、任务队列:任务队列用于存储待执行的任务。这些任务可以是函数、方法或其他需要多线程环境中执行的操作。2、线程池管理:线程池管理器负责创建、销毁和管理线程。它会监视任务队列中的任务,根据需要创建线程,执行任务,并在任务完成后将线程放回池中以供重用。

FJN110的博客 100

革命性Rust集成:Unreal Engine 5全栈开发指南2025

你是否在Unreal Engine开发中面临C++编译缓慢、内存安全问题或模块化挑战?虚幻引擎官方统计显示,78%的开发团队报告C++项目平均编译时间超过15分钟,而65%的运行时崩溃源于内存管理错误。**unreal-rust**项目通过将Rust的内存安全、现代语法与UE5的强大渲染能力相结合,彻底改变游戏开发流程。本文将带你从零开始构建Rust驱动的UE5项目,掌握实体组件系统(ECS)架构...

gitblog_00555的博客 608

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

深度解析Rust游戏插件架构:黑神话悟空实时地图渲染原理与技术实现

wukong-minimap是一款专为《黑神话:悟空》设计的高性能实时地图插件,采用先进的Rust语言和DLL注入技术,为玩家提供精准的内置小地图导航体验。该插件通过内存注入、实时渲染和高效数据处理的创新架构,实现了游戏内地图系统的无缝集成。 ## 技术背景与挑战 ### 游戏插件开发的复杂性 现代游戏插件开发面临多重技术挑战,特别是在《黑神话:悟空》这样的AAA级游戏中。传统的游戏插件通常

gitblog_00870的博客 885

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

【RustAI基础设施开发】:揭秘高性能AI系统背后的Rust核心架构

掌握RustAI基础设施开发,构建高性能、高并发的AI系统。本文揭秘基于Rust的核心架构设计,适用于模型推理引擎与分布式训练场景,兼顾内存安全与极致性能,助力企业级AI应用落地,值得收藏。

IterStream的博客 320

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

从入门到精通Rust,你必须走对的7个关键步骤

掌握Rust高效编程的完整路径,这份rust学习路线图涵盖从基础语法到并发处理、内存安全等核心概念,适用于系统开发与WebAssembly场景。循序渐进掌握实战项目技巧,提升性能与安全性,值得收藏。

LogicPlex的博客 794

NautilusTrader Rust核心引擎解析:极致性能的交易系统架构

在算法交易领域,性能是决定成败的关键因素。传统交易系统往往面临一个困境:研究阶段使用Python进行快速原型开发,但生产环境需要重写为C++或Java以获得更好的性能。NautilusTrader通过Rust核心引擎彻底解决了这个问题,实现了研究到生产的无缝衔接。 **读完本文你将掌握:** - NautilusTrader Rust核心架构设计哲学 - 高性能时间处理和数值计算实现 - 内存安...

gitblog_00879的博客 1294

【2cha】Cargo.toml 深度解读:2cha 项目结构分析

fill:#333;important;important;fill:none;color:#333;color:#333;important;fill:none;fill:#333;height:1em;twocha-cli命令行界面twocha-lib对外API核心逻辑协议定义加密库RustCrypto平台适配层。

weixin_43219667的博客 997

智能影记(Memoria)终期实训成果总结:核心系统架构设计与高保真原型落地

本文介绍了《智能影记(Memoria)》项目的设计与实现,针对个人数字影像管理中存在的隐私泄露、素材混乱和创作门槛高等痛点,提出了一套端云协同的智能解决方案。项目采用Clean Architecture分层设计,构建了包含无感净洗、时空聚类、多模态语义索引等核心功能的系统架构,并通过Figma高保真原型与Flutter实现了优雅的UI交互。特别设计了兼顾隐私保护的端侧优先技术路线,支持自然语言搜图、AI故事创写等高级功能,最终打造了一款安全、易用的智能影像管理工具,有效解决了数字囤积与创作焦虑问题。

MoreSome_9256的博客 523

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 571

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 162

Rust组织管理(AI回答)

你想做的事JS / Python 做法Rust 做法把一个文件纳入工程新建文件即可新建 xxx.rs 后,必须在入口写mod xxx;挂载对外暴露函数/结构体export(Python 默认全公开)默认全私有,必须显式加pub引入别处的函数use crate::模块名::函数名;找路径的基准词./ 或 ../(从 src 根出发)、(上一级 ../)、(当前级 ./)日常写项目:不要用 #[path],直接遵守默认规则——

yaoct的博客 153

自建 RustDesk 服务端后,做一个“装完就能连“的客户端

目前市面上的远程工具(如向日葵、toDesk等)免费版基本上都卡的不行,而且收费版好像也会卡。如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 626

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 121

GitHub 热榜项目:日榜(2026-11-10)

本期共 11 个热门开源项目,合计新增 13,136 stars。榜单前三分别是 Anthropic 的 Agent Skills 仓库、Meta 开源的 React 设计系统 Astryx(+3,278)和用户名检索工具 sherlock(+4,267,本期涨星最多)。其余项目覆盖 DeepMind 的物理引擎 MuJoCo、Claude 官方示例集、自托管智能体记忆系统 GBrain、用 Rust 写的浏览器自动化 CLI、基于 WiFi 信号的人体感知平台 RuView、多市场股票分析工具,以及 Ho

u130130的博客 443
上一篇: CUDA 统一内存消除 TensorRT 推理输入拷贝开销的底层实践
下一篇: Rust 导出 C API 的内存安全释放规则:在分布式框架调用中守住底线
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值