Rust 所有权:内存管理新流派

Rust学习教程10 - 所有权 所有权 所有的程序都必须和计算机内存打交道,如何从内存中申请空间来存放程序的运行内容,如何在不需要的时候释放这些空间,成了重中之重,也是所有编程语言设计的难点之一。在计算机语言不断演变过程中,出现了三种流派: 垃圾回收机制(GC),在程序运行时不断. 阅读详情

在 Rust 中每个值都只能被一个所有者拥有,当这个值被赋给其他所有者,原所有者无法再使用。正是这种机制保证了 Rust 语言的内存安全,从而无需自动垃圾回收,也无需手动释放。所有权是 Rust 最重要的特性之一。下面来看一个简单的例子。

fn main() {
    let s = String::from("hello");
    let a = s;          // 字符串对象“hello” 的所有权被转移
    println!("{}", s); // error! 无法再使用 s
} 

上面展示了所有权转移的基本案例, 由于a获得了字符串的所有权,s无法再使用。这可能和现存的编程语言有很大的区别,事实上在 Rust 之前,我所了解的所有语言中这样用是完全正确的,但是现在我明白了这么做的奇妙之处。

为什么要转移所有权?

Rust 定位系统编程语言,要求内存安全以及内存管理无运行时开销。

何为内存管理的运行时开销,这里要拿 Java 做个例子,Java 自称是内存安全的语言,因为 Java 中程序员无需手动管理内存(程序员自己管理是内存不安全的源头), Java 采用垃圾自动回收,所有的 Java 程序都运行在 Jvm 中,Jvm 在 Java 程序运行期间,必须时刻监控、遍历 Java 对象树,以鉴别出堆上哪些变量不再被引用,在一定的时间周期到达时自动释放那些不被引用变量的内存。

也就是说,Jvm 在运行着一个和实际程序完全无关的垃圾回收进程,这被称为运行时开销。当然,由于 Java 的定位,这些开销是可以完全不用考虑的。

C/C++ 作为系统编程语言,由程序员手动管理内存,在malloc后free必须被使用,否则会发生内存泄漏,最终占满进程的所有内存空间,在 C++ 中是new和delete这一对好兄弟。目测这很好处理,只要记得同时使用就好了,但是当问题变得复杂,这将变得困难而又容易出错。来看一段 C 代码:

#include <stdio.h>
#include <malloc.h>
 
int* func()
{
    int *p = malloc(sizeof(int));
    /*
       do something
    */
    return p;
} 

谁能保证在这个函数的外部,有人记得这个指针是 指向堆而不是栈上的,并且记得调用free()?这很难说, 尤其是情况变得更加复杂的时候… 因此,C/C++ 高手很难炼成,连 Goole 都因它犯难,试图用Go取代部分 C/C++ 的应用场景,Go的特性这里不多提,它无疑是一个优秀的编程语言,出身名门,虽然自我定位是系统编程语言,但是目前主要被用于网络编程,它也采用了垃圾自动回收机制,因此,运行时开销是无法避免的。

上面说到的 Java 和 C/C++两个例子,代表了当前内存管理的两个流派,两种方式都存在一定的痛点,这就是为什么 Rust 决定采用一种完全不同的管理方式,通过转移所有权,Rust 做到了安全的内存管理。那么现在回到主题,来看 Rust 是如何管理内存的。

Rust 的内存管理

Rust 中没有自动垃圾回收(Auto GC), 也不需手动管理,这一工作在编译阶段,由编译器来负责。编译成功后,变量内存何时回收已经被确定,硬编码到二进制程序中了,程序自己运行到该回收的时候就自动回收了。编译器如何做到如此智能?Rust 中的所有权系统功绩首屈一指。下面来分别介绍所有权系统的各种特性。

作用域

每一个变量被限定在一个作用域内有效,和大多数编程语言一样,{}被看作一个作用域的标志,但不同的是,在运行到}时,不仅回收栈上的变量,也回收堆上的内存。

fn func() {
    let n = 2;  // 在栈上分配
    let s = String::new(); // 在堆上分配
} 

如上,在堆上分配的空间也被回收了,这看似很正常,但是如果 s被作为返回值,它的作用域改变了,它仍然能够最终在某个}(所处作用域结束时)处被释放,作用域保证了变量一定会被回收,也就避免了像上面 C 语言忘记调用free()的情况了。

到底是如何回收的?在 Rust 中,类使用struct定义,或者你可以不叫它“类”,而是别的名字。每个对象都实现了一个trait, 即Drop(如果你熟悉 Java 可以把trait理解为“接口”),Drop 包含一个方法drop(), 在任何对象离开作用域的时候,它的drop()会被自动调用,从而释放自身内存。

转移

正如本文开始提到,一个值只能有一个拥有者,因此当赋值给其他的变量时,所有权被转移,原所有者不能继续使用。在 Rust 中,所有权转移称为 move. 本文开头的赋值是一个所有权转移的基本例子,下面我们再来看一个稍微复杂的。

fn main() {
    let s = String::from("hello");
    func(s);    // 字符串的所有权转移到了func()的内部
    let a = s;  // error  s 已经无法被使用
}
 
fn func(s: String) {
    println!("{}", s);  // s 将在离开作用域时被释放
} 

但是有时在作为函数参数使用后,仍要使用怎么办,在函数结尾将其 return是一个解决办法,但不是好办法,后面马上会讲到的借用,会很好的解决这个问题。

值得注意的是,move的例子中我都使用的是 String::new()或者String::from()来创建一个字符串对象, 为什么不直接用字符串类型例如let s = "hello"或者其他类型如i32做演示,因为 move 规则对它们并不适用!

fn main() {
    let n = 2;   // i32 类型
    let a = n;
    println!("{}", n);  // success! 并没有问题
} 

看起来这和之前的理论矛盾了,但实际上所有权规则对所有类型都是适用的,只不过 Rust 为了减少编程的复杂度,在基本类型赋值的时候, 拷贝了一份原内存作为新变量,而不是转移所有权。也就是说本例中 a 是一个独立的变量,拥有独立的内存,而不是从n处获得。n也得以保留了对应值的内存,因而可以继续使用。

以上说的“基本类型”到底是哪些类型,常用的 i32, bool等都是。具体来说是实现了Copy这个trait的类型,基本类型 Rust 已经内置实现了,也就是说,我们完全可以自己为String类型实现Copy ,从而在字符串对象赋值的时候,拷贝而不转移。

注意! let s = "hello"中的 s 并不是基本类型变量,虽然赋值也不会转移所有权,那是因为 s的类型是&str, 是借用在起作用而不是拷贝!

上面的 赋值和传参是move的隐式调用,有些情况下,必须通过关键字move显式指定,否则无法编译通过,比如闭包就是一个常见的情况。文章篇幅考虑,这里先不介绍闭包,让我们快速进入前面多次提到的借用,这也是本节最后一部分。

借用

使用转移所有权有的时候还是太麻烦了,正如现实中一样,我可以把自己的东西借给被人用,但仍然具有所有权,Rust 中支持借用(borrow),用&表示,有些文章中也称为“引用”,但是我觉得这样并不好,因为这里的&与在 C/C++ 中&有很大的区别, 而且编译器都叫它 “borrow” 而非 “refer” !

来看一下如何用借用解决所有权问题。

fn main() {
    let s = String::from("hello");
    let a = &s;
    println!("{}", s);  // success
    println!("{}", a);  // success, print "hello"
    func(&s);  // success
}
 
fn func(s: &String) {
    println!("{}", s);
} 

这段代码是借用的基本用法,a通过&借用了s的内存,并没有转移,但现在a能访问s的空间了,Rust 允许有多个借用者,传入到函数func()的也是s的一个借用,但是它在func()结束时被释放了。

但是,在被借用期间,拥有者不允许修改变量,或者转移所有权!这看似是一个礼节问题,但实则是为内存安全考虑,修改值将导致这些借用的值与本身不一致,引发逻辑错误,转移所有权必将导致借用失效,因此,这不被允许!让我们尝试在func(&s)之后转移所有权。

fn main() {
    let s = String::from("hello");
    ...
    func(&s);
    let b = s;  // error  s 已被借用,无法转移
} 

到这里为止,提到的借用都是指不可变借用,也可以说是“只读借用”,借用者允许有多个,借用者不允许修改值,这不难理解,如果有一个借用者修改了值,必将造成数据的不一致。

但有时我们还真的需要修改值!比如我们熟悉的swap(), 这时 Rust 提供了可变借用(&mut),可变借用者能够对数据进行修改,当然前提是这个值本身是可变的(mut)。简单考虑,这里用字符串连接作为例子。

fn main() {
    let mut s = String::from("hello");
    func(&mut s);
}
 
fn func(s: &mut String) {
    s.push_str(" world");  // s = "hello world"
} 

通过可变借用,func()函数得以修改了s的值,但是可变借用有一个非常严格的限制,那就是只能有一个可变借用。可变借用期间,不允许有其他的任何借用,包括不可变借用; 可变借用期间,拥有者本身也不能进行任何操作,不能转移,不能修改值。

从某种角度来看,可变借用和转移没什么区别,它相当于一个临时的所有权转移,当接收转移的那个变量离开作用域,所有权自动物归原主 。

到此为止,Rust 的所有权系统基本介绍完毕,正是这些规则撑起了 Rust 内存安全的大旗,完备而相互论证,借用理论来源于生活,符合情理,不得不说 Rust 内存管理设计的非常精妙!

Tips

提炼出本文得出的几个有用的 Tip:

  • 基本变量(实现了Copy)的变量赋值时不转移所有权,而是拷贝
  • 被借用期间,不允许修改值
  • 可变借用只允许一个,借用期间,拥有者不允许任何操作
  • 可变借用相当于临时的所有权转移,借用释放后,物归原主

完。

× 如转载请注明出处,谢谢 ×

网络安全工程师(白帽子)企业级学习路线

第一阶段:安全基础(入门)

img

第二阶段:Web渗透(初级网安工程师)

img

第三阶段:进阶部分(中级网络安全工程师)

img

学习资源分享

三阶段:进阶部分(中级网络安全工程师)

[外链图片转存中…(img-pqtovpVZ-1715739053447)]

学习资源分享

Rust深度学习绑定实战:内存安全与ABI兼容性设计 深度学习绑定本质上是跨语言内存所有权与ABI契约的系统工程。在Rust中构建稳定绑定,需深入理解C/C++库的资源生命周期、错误传播机制及线程安全模型,而非简单调用bindgen生成FFI接口。核心挑战在于将C++的RAII语义、引用计数和异常处理,精准映射为Rust的Drop、Send/Sync和Result类型系统——这直接决定显存泄漏、段错误或静默崩溃等生产级风险。典型场景包括PyTorch/TensorFlow/ONNX Runtime的Rust封装,尤其在边缘推理、高吞吐服务和WASM部署中,绑定 阅读详情

相关推荐

从PyTorch转Rust?tch-rs、Candle、Burn、DFDX保姆级上手对比(附代码示例)

本文详细对比了Rust生态中四大机器学习框架tch-rs、Candle、Burn和DFDX的使用体验,从环境配置、模型定义到训练流程和部署方案,为PyTorch开发者提供平滑过渡到Rust的实践指南。通过代码示例展示各框架在API设计、性能优化和生产部署方面的差异,帮助开发者根据项目需求选择最适合的Rust机器学习框架。

weixin_42116058的博客 324

深入浅出 - Rust 所有权与内存管理机制

Rust 学习

举世誉之而不加劝,举世非之而不加沮,定乎内外之分,辩乎荣辱之境,斯已矣。 3227

保姆级教程:在STM32CubeIDE上快速部署micro_ros到STM32F407(附常见问题解决)

本文提供了一份详细的保姆级教程,指导开发者如何在STM32CubeIDE上快速部署micro_ros到STM32F407微控制器。内容涵盖从Windows与Ubuntu双环境搭建、micro-ROS静态库编译、STM32CubeIDE工程深度集成,到串口通信联调与常见问题解决的完整流程,旨在帮助读者构建稳定可靠的ROS2与嵌入式设备通信系统。

o4p5q6r7s的博客 324

Rust入门-所有权

这里可以给出一个通用的规则: 任何基本类型的组合可以 Copy ,不需要分配内存或某种形式资源的类型是可以 Copy 的。可以理解成,所有权移交之后,就可以大胆放心的抛弃先前的拥有者。,栈和堆的结构特性决定了一些值适合放在哪些位置,能够有更好的性能和空间效率。,不会把旧值的所有权给新变量(新拥有者),没有发生所有权变化的现象。的,因为你需要复制一份数据,万一你这个数据非常大,复制起来非常耗时耗资源。,该结构体就是字符串结构,保存了堆中数据的地址、长度、容量等数据。,即在堆中生成一份相同的数据,赋给新变量。

vince1998的博客 1384

解决uc浏览器劫持video标签问题

解决uc视频悬浮播放 ,video标签被浏览器劫持 ,vide0适配

smile_y_y的博客 3454

Unity中5自由度机械臂运动控制与夹爪交互仿真实践

本文详细介绍了在Unity中实现5自由度机械臂运动控制与夹爪交互仿真的完整流程。从模型导入、物理组件配置到关节运动控制算法(包括逆运动学IK),再到夹爪抓取逻辑和工业分拣案例实战,提供了可落地的代码示例与性能优化方案,助力开发者快速掌握机械臂仿真核心技术。

weixin_29021757的博客 447

Rust - 所有权

我们已经见过字符串字面值 let s =“hello”,s 是被硬编码进程序里的字符串值(类型为 &str )。字符串字面值是很方便的,但是它并不适用于所有场景。字符串字面值是不可变的,因为被硬编码到程序代码中并非所有字符串的值都能在编写代码时得知例如,字符串是需要程序运行时,通过用户动态输入然后存储在内存中的,这种情况,字符串字面值就完全无用武之地。为此,Rust 为我们提供动态字符串类型:String,该类型被分配到堆上,因此可以动态伸缩,也就能存储在编译时大小未知的文本。

日拱一卒无有尽,功不唐捐终入海 1276

碰撞检测 | 图解视线生成Bresenham算法(附ROS C++/Python/Matlab实现)

Bresenham视线生成是一种高效的算法,用于在二维网格上绘制直线。Bresenham算法可以应用在栅格地图中进行一维碰撞检测,即检查起点和终点间直线是否穿过障碍栅格。本文图解Bresenham碰撞检测的原理,并给出ROS C++/Python/Matlab三种实现加深理解

FRIGIDWINTER的博客 1万+

【rust】11、所有权

rust 所有权

呆呆的猫的博客 1271

RNA-seq分析:Step4(比对)

预处理之后的fastq文件,可以使用HISAT2软件将reads比对至参考基因组上。HISAT2软件将reads比对至参考基因组上的步骤如下:1. 对参考基因组进行建索引。对参考基因组进行预处理,生成索引文件,包括基因组序列的FM索引和SA索引。2. 将原始的reads进行预处理。包括去除接头序列、去除低质量的碱基,以及进行过滤,得到质量较高的、可靠的reads。3. 利用建立的FM索引和SA索引,将处理后的reads与参考基因组进行比对。首先,通过FM索引,快速找到与reads匹配的可能位置;

沉香best的博客 2601

YOLOv11改进 | Neck篇 | 独创HFPN利用分层特征融合块HFFB模块融合多层次特征改进yolov11(全网独家创新)

本文给大家带来的最新改进是利用分层特征融合块HFFB创新yolov11的neck部分我称之为HFPN,这个模块可以融合局部特征、全局特征、中间特征将三种特征融合在一起辅助yolov11进行检测,经过我的设计分为三种可以针对大目标、小目标、标准目标的检测方式均不同,大家可以根据自己的数据集进行不同的选择,本文的内容为我独家创新。YOLOv11改进系列专栏——本专栏持续复习各种顶会内容——科研必备目录一、本文介绍二、原理介绍三、核心代码四、添加方法4.1 修改一4.2 修改二4.3 修改三4.4 修改四。

Snu77的博客 5222

Rust 所有权(Ownership)学习

Rust通过所有权系统在编译期确保内存安全,无需运行时垃圾回收。本文介绍了内存管理的三种方式(GC、手动管理、所有权),并对比了栈与堆的特性。Rust所有权的核心规则包括:每个值有唯一所有者,离开作用域自动释放。通过String类型示例,展示了所有权转移(Move)、克隆(Clone)和拷贝(Copy)的差异。函数传参同样遵循所有权规则,堆数据转移所有权,栈数据自动拷贝。Rust的所有权机制既保证了内存安全,又避免了运行时性能损耗。

目前专注区块链相关技术的学习与分享 1098

【YOLOv8系列】YOLOv8的webUI界面设计;通过Streamlit实现YOLOv8的可视化交互界面设计

但是我为了避免重复性的工作,且为了避免重复安装之前(安装pytorch和yolov8时)已经安装好的库,因此写了一个python脚本进行安装;需要提前在有网络连接的电脑上下载所有必要的依赖项,然后将这些文件传输到离线的机器上进行安装。脚本将自动跳过已安装的包,并安装其余的 .whl 文件。在离线的机器上,切换到包含下载好的文件的目录。证明我们的streamlit安装成功了。证明你的streamlit安装成功了。第一步:在有网络连接的电脑上下载。第二步:将下载的文件传输到离线机器。文件)传输到离线的机器上。

AnChenliang_1002的博客 1567

Rust 入门,基础类型 -所有权和借用 (四)

之前提到过,本章会用String作为例子,因此这里会进行一下简单的介绍我们已经见过字符串字面值 let s="hello", s是被硬编码进程序里的字符串值 (类型为 &str) . 字符串字面值是很方便的, 但是它并不适用于所有场景1. 字符串字面值是不可变的, 因为被应变到程序代码中.2. 并非所有字符串的值都能在编写代码时得知。

m0_48050264的博客 631

YOLOv11 TensorRT极致加速:C++部署性能优化完全指南

购买即可解锁300+YOLO优化文章,并且还有海量深度学习复现项目,价格仅需两杯奶茶的钱,别人有的本专栏也有!

LXY_LOVE36的博客 118

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

第N次入门Rust - 3.所有权(Ownership)

这一篇介绍Rust的第一个核心:所有权,建议在忘了所有权的基础知识的时候多看本文两遍~

你好! 2012

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

rust 入门,基础类型 -所有权和借用 (四)

之前提到过,本章会用String作为例子,因此这里会进行一下简单的介绍我们已经见过字符串字面值 let s="hello", s是被硬编码进程序里的字符串值 (类型为 &str) . 字符串字面值是很方便的, 但是它并不适用于所有场景1. 字符串字面值是不可变的, 因为被应变到程序代码中.2. 并非所有字符串的值都能在编写代码时得知。

c10587的博客 350

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Rust 所有权和借用

文章目录Rust 所有权和使用所有权栈和堆所有权原则变量绑定背后的数据交互函数传值与返回引用和借用引用与解引用不可变引用可变引用悬垂引用 Rust 所有权和使用 所有程序都需要和内存打交道,有三种流派 垃圾回收机制(gc),程序运行时不断寻找不在使用的内存,如 Java,go 手动管理内存的分配释放,如 C++ 通过所有权来关系内存,编译器在编译的时候进行检查 所有权 不同于 go 语言的 gc,Rust 使用第三种 所有权系统,只在编译时检查,不在运行期检查,不会有性能损失。 栈和堆 栈和堆都是为了给

mr1jie的博客 739

[初学rust] 03_所有权

Rust 中每一个值都被一个变量所拥有,该变量被称为值的所有者一个值同时只能被一个变量所拥有,或者说一个值只能拥有一个所有者当所有者(变量)离开作用域范围时,这个值将被丢弃(drop)人话:这个就是C++移动构造创建出来的unique_ptr变量只有移动,没有深拷贝想要深拷贝,需要调用clone()方法同时,和C++ 表现一样,对于内置类型(基础类型),直接拷贝就好了。。。。由于这玩意儿表现形式就是unique_ptr,所以在函数调用上,就会很恶心,

u012989445的博客 393

66个让你对Rust又爱又恨的场景之一:变量与值

通过66个精心设计的场景,我们详细解释Rust语言的所有权机制,帮助你掌握内存安全和并发编程的核心原理,提升编程技能和效率。

wuzhenben的博客 1234

Rust学习及Rust语言圣经阅读笔记

手动管理内存的分配和释放,在程序中,通过函数调用的方式来申请和释放内存,典型代表:C++· 垃圾回收机制(GC),在程序运行时不断寻找不再使用的内存,典型代表:Java, Go。· 通过所有权来管理内存,编译器在编译时会根据一系列规则进行检查。

zjy997的博客 162

开发语言全维度整合资料

编程语言发展与应用全景摘要 本文系统梳理了编程语言的演进历程和现代应用场景。语言发展树以时间轴和谱系关系为主线,涵盖从早期机器语言到新兴语言Mojo的全貌,包括四大分支:编译型语言、脚本语言、函数式语言和新兴语言。应用对比表详细分析了20+主流语言/框架的适用领域、优劣势及代表工具,如C/C++适合系统开发,Python主导AI领域,React/Vue/Angular构成前端三大框架。选型决策树提供结构化选择路径,通过"性能→场景→生态"的递进逻辑,帮助开发者根据项目需求(如云原生、移动

WSSWWWSSW的博客 1486

rust: Fan-out/Fan-in Pattern

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

Geovin Du Dream Park 159
上一篇: Kotlin教程(九)泛型
下一篇: Spring Security源码分析九:Spring Security Session管理
heike_沧海
博客等级 码龄3年 4649粉丝 391原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值