文档章节

rust04所有权

AllenOR灵感
 AllenOR灵感
发布于 2017/09/10 01:17
字数 1408
阅读 2
收藏 0

所有权指涵盖的范围有: 变量作用域、垃圾处理机制、引用,围绕着几种行为来阐述所有权概念。

 

变量作用域(Scope)

任何编程语言中都存在变量作用域的概念, Rust中的变量作用域与其他编程语言也基本一致;作用域大致上会分为: 全局作用域, 函数内作用域.

全局作用域

在下面这段代码中, PROGRAM常量和main函数就是一个全局作用域; 反过来讲就是当前程序代码中,全局作用域拥有两个对象, 第一个对象是 PROGRAM 常量, 第二个对象是 main 函数。

const PROGRAM: &'static str = "Rust";

fn main() {
    println!("{}", PROGRAM);
}


# 作用域的形式可以这么理解, global_scope中有两个对象.
global_scope = {
    "const PROGRAM": "Rust"
    "fn main": "println!({}, PROGRAM)"
}
函数内作用域

变量不能let(定义)在全局作用域中, 所以全局作用域能做的事情并不多: 定义常量、定义函数、引用其他模块文件; 更多的合法操作实在函数作用域中完成: 定义变量、打印变量、逻辑计算、逻辑判断、函数调用和执行等.

const PROGRAM: &'static str = "Rust";

fn main() {
    let s = "abc";                      // 定义变量
    let sf = simple_function();         // 执行函数
    let sum = 10 + 15;                  // 逻辑计算
    if sum > 0 {                        // 逻辑判断
        println!("{} {} {}", PROGRAM, s, sum);  // 打印常量和变量
    }
}

fn simple_function() {
    let sf = "Simple Function";         // 定义变量
    sf                                  // return 变量
}


# 作用域的形式可以这么理解, global_scope中有三个对象, 其中
# main对象中又有一个二级作用域, simple_function对象中也有一个
# 二级作用域.
global_scope = {                        // 作用域

    "const PROGRAM": "Rust",

    "main": {                           // 作用域
        "let s": "abc",
        "let sf": "Simple Function",
        "let sum": 25,
    },

    "simple_function": {                // 作用域
        "let sf": "Simple Function"
    }
}

 
 

垃圾处理机制

像其他具备GC回收机制编程语言一样,当程序执行完成并跳出某个作用域(通常指的是一个函数)时,该作用域中的所有变量将会失效(被回收);除此之外, Rust对垃圾回收这件事情上还具备其他的能力和行为, 例如: 当需要对存储在堆(Heap)中的数据进行复制时, 被赋值对象将具备赋值对象的数据,而赋值对象将会被回收。

离开作用域时回收数据
fn simple_function() {
    let sf = "Simple Function";    // sf变量开始生效
    println!("{}", sf);            // sf变量仍然生效
}                                  // sf变量不再生效

fn main() {
    simple_function();             // 当该函数执行完成后, sf变量就会被回收
    println!("{}", sf);            // 报错: sf变量不存在.
}
变量传递后即刻失效
fn simple_function(sf: String) {
    println!("simple_function: {}", sf);
}

fn main() {
    let s = String::from("hello");
    simple_function(s);
    println!("main: {}", s);
}



# 报错
Compiling ownership v0.1.0 (file:///opt/learn_rust/ownership)
error[E0382]: use of moved value: `s`
  --> src/main.rs:10:26
   |
9  |     simple_function(s);
   |                     - value moved here
10 |     println!("main: {}", s);
   |                          ^ value used here after move
   |
   = note: move occurs because `s` has type `std::string::String`, which does not implement the `Copy` trait
通过return让它重回原作用域
fn simple_function(sf: String) -> String {  // -> String 声明返回值类型
    println!("simple_function: {}", sf);
    sf
}

fn main() {
    let s = String::from("hello");
    let s = simple_function(s);     // 利用返回值, 重新定义变量.
    println!("main: {:?}", s)       
}
数据存储在栈上时, 变量再赋值不会回收原变量
fn main() {
    let a = 10;                 // rust会将固定不变的值存储在栈(Stack)上.
    let b = a;                  // rust对栈上的数据默认采取深复制.
    println!("{} {}", a, b);
}

fn main() {
    let a = "abc";              // 与上面是一样的.
    let b = a;                  
    println!("{} {}", a, b);
}
当变量存储再堆上时, 变量再赋值就会回收原变量(所有权转移)
fn main() {

    // rust会将这种未知大小的数据存储在堆(Heap)上.
    // 因为String::from这种结构的数据支持push_str
    // 来扩充它的大小, 因此从本质上来讲是未知大小.
    let a = String::from("hello");  

    // rust对堆上的数据默认采取移除上一个变量创建
    // 新变量的机制, 这种做法在术语上叫做所有权转移.
    let b = a;                  

    // 这里会报错, a变量已被移除
    println!("{} {}", a, b)     
}


# 报错信息
Compiling ownership v0.1.0 (file:///opt/learn_rust/ownership)
error[E0382]: use of moved value: `a`
  --> src/main.rs:10:23
   |
7  |     let b = a;
   |         - value moved here
...
10 |     println!("{} {}", a, b)
   |                       ^ value used here after move
   |
   = note: move occurs because `a` has type `std::string::String`, which does not implement the `Copy` trait

 
 

引用(reference)

不可变更引用(默认)
fn main() {
    let a = 10;

    // b变量是一个指针, 它并没有实际数据的所有权.
    let b = &a;

    // 引用是在栈上创建一个指针指向栈数据.
    // 它比在栈上深复制更轻量.
    println!("{} {}", a, b)     
}
可变引用
fn main() {
    let mut a = "hello";
    a + "b"
    println!("{}", a)
}
引用的注意事项
可变对象不能被多次引用, 这会导致数据竞争.
fn main() {
    let mut a = 10;
    let b = &mut a;
    let c = &mut a;
}


# 报错
Compiling ownership v0.1.0 (file:///opt/learn_rust/ownership)
error[E0499]: cannot borrow `a` as mutable more than once at a time
  --> src/main.rs:18:18
   |
17 |     let b = &mut a;
   |                  - first mutable borrow occurs here
18 |     let c = &mut a;
   |                  ^ second mutable borrow occurs here
19 | }
可变对象被可变引用之后, 再次引用会导致数据不一致.
fn main() {
    let mut a = 10;

    // 可变对象被可变引用走了
    let b = &mut a;

    // 这里会报错, 因为数据状态任何时刻都可能会改变,
    // 这是不可预期的, 所以rust不允许这种情况的出现.
    println!("{} {}", a, b)
}
可变对象被可变引用之后,数据不一致的解决办法
fn simple_function(sf: &mut String) -> String {
    sf.push_str(" world!");
    let new_sf = sf.clone();
    new_sf
}

fn main() {
    let mut a = String::from("hello");

    // 站在变量的角度来讲: &mut a 的专业术语为<可变引用>
    // &mut a 当做参数传递给函数时, 专业术语为<可变借用>
    let b = simple_function(&mut a);  

    println!("a: {}\nb: {}", a, b)
}

本文转载自:http://www.jianshu.com/p/87f983c840a4

共有 人打赏支持
AllenOR灵感
粉丝 10
博文 2634
码字总数 82983
作品 0
程序员
ARC中__bridge, __bridge__transfer, __bridge_retaine

多数情况下,Objective-C 对象和 Core Foundation 对象之间互相转换时, 我们都应该使用bridge。但是有时候我们确实需要给予 ARC 某个对象的所有权, 或者解除 ARC 对某个对象的所有权。这种情况...

lingfeng72
2015/11/24
24
0
对BOOST 中同步互斥的一些理解

对BOOST 中同步互斥的一些理解 首先,BOOST中有4种有关互斥量得概念。 1.LOCKABLE :仅支持排它型所有权 2.TIMEDLOCKABLE:支持带超时的排它型所有权 3.SHAREDLOCKABLE: 支持带超时的排他型所...

江浸月
2013/02/18
0
1
99%币圈人都不知道的ERC1190,到底是什么?

引言 基于以太坊网络的token标准有很多。其中,大家最熟知的想必就是ERC20和ERC721了。 除此之外,token的标准还有ERC223、ERC777、ERC1155和ERC1190,想必此刻大部分小伙伴已经懵圈了。 少年...

ONETOP评级
09/11
0
0
chgrp - 改变文件的组所有权

NAME chgrp - 改变文件的组所有权 总览 chgrp [选项] 组文件... POSIX 选项: [-R] [--] Austin 草拟选项: [-hHLPR] GNU 团体指示: [--reference=rfile] GNU 选项 (简易格式): [-cfvR] [--hel...

zhongyilin
2014/03/04
0
0
《从零开始学Swift》学习笔记(Day 61)——Core Foundation框架之内存管理

原创文章,欢迎转载。转载请注明:关东升的博客 在Swift原生数据类型、Foundation框架数据类型和Core Foundation框架数据类型之间转换过程中,虽然是大部分是可以零开销桥接,零开销并不意味...

智捷课堂
2016/01/18
31
0

没有更多内容

加载失败,请刷新页面

加载更多

arts-week10

Algorithm 905. Sort Array By Parity - LeetCode Review Who’s Afraid of the Big Bad Preloader? 一文读懂前端缓存 一个网络请求3个步骤:请求,处理,响应,而前端缓存主要在请求处响应这两步...

yysue
今天
4
0
00.编译OpenJDK-8u40的整个过程

前言 历经2天的折腾总算把OpenJDK给编译成功了,要说为啥搞这个,还得从面试说起,最近出去面试经常被问到JVM的相关东西,总感觉自己以前学的太浅薄,所以回来就打算深入学习,目标把《深入理...

凌晨一点
今天
5
0
python: 一些关于元组的碎碎念

初始化元组的时候,尤其是元组里面只有一个元素的时候,会出现一些很蛋疼的情况: def checkContentAndType(obj): print(obj) print(type(obj))if __name__=="__main__": tu...

Oh_really
昨天
6
2
jvm crash分析工具

介绍一款非常好用的jvm crash分析工具,当jvm挂掉时,会产生hs_err_pid.log。里面记录了jvm当时的运行状态以及错误信息,但是内容量比较庞大,不好分析。所以我们要借助工具来帮我们。 Cras...

xpbob
昨天
162
0
Qt编写自定义控件属性设计器

以前做.NET开发中,.NET直接就集成了属性设计器,VS不愧是宇宙第一IDE,你能够想到的都给你封装好了,用起来不要太爽!因为项目需要自从全面转Qt开发已经6年有余,在工业控制领域,有一些应用...

飞扬青云
昨天
6
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部