Rust简明教程第三章-所有权与借用

已于 2024-07-04 17:12:50 修改
阅读量1.2k 收藏 17
点赞数 27
分类专栏： 后端 文章标签： rust 数据库 开发语言
于 2024-07-04 17:08:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62799021/article/details/140184525
版权

观看B站软件工艺师杨旭的rust教程学习记录，有删减有补充

Stack&Heap 栈内存和堆内存

  • stack用于存放函数的参数、局部变量等
  • stack只能从栈顶操作数据，压栈push,出栈pop,后进先出
  • stack存储的数据必须有已知的固定大小
  • stack写入读取数据比stack快得多
  • heap存储编译时大小未知或运行时可能发生变化的数据
  • heap分配空间先标记一块内存空间为在用，并返回一个指向这块地址的指针
  • heap分配内存返回的指针大小已知，heap的指针存储在stack上

所有权

  • 每个值都有一个变量，这个变量是该值的所有者
  • 每个值同时只能有一个所有者
  • 当所有者超出作用域（scope）时，该值将被删除

字符串字面值，大小已知，存储在stack上

fn main(){
    //s不可用
    let s = "Hello";//s可用

}//s作用域结束，s不可用

integer、array等大小固定的值存储在stack上，而String类型的值数据存储在heap上，String类型的值是可变的，地址存储在stack中

fn main() {
    let mut s = String::from("Hello");
    s.push_str(",World");
    println!("{}", s); //Hello,World
}//s离开作用域调用drop

Move 变量和数据的交互方式

Rust处理资源时，默认行为是move（转移/移动）

对于已知固定大小的值，move的方式是在stack上复制stack上存储的值并绑定到新声明的y变量

fn main() {
    let x = 5;//x拥有5
    let y = a;//y拥有copy的5
    println!("{}", x); //5
    println!("{}", y); //5
}

对于可变大小的值，move的方式是在stack上复制stack存储的指向heap的指针（、长度、容量），让原来绑定指针的变量失效

fn main() {
    let s1 = String::from("Hello");
    let s2 = s1;//s1不再拥有"Hello"，所有权move到s2
    // println!("{}",s1);//s1失效，s1不可用
    println!("{}",s2);//Hello
}

Shallow copy&Deep copy 浅拷贝和深拷贝

  • 浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存（开销小）
  • 深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象，是“值”而不是“引用”（开销大）

Rust对存储在heap上的数据类型不仅复制了指针还让原来的变量失效，所以称作Move(移动),基础类型的值存储在satck中直接复制和复制指针没有太大的性能差距，而存储在heap上的复杂类型直接复制值会消耗大量性能

如果要实现对heap上的数据深拷贝，使用clone()方法,s1和s2所有权没有改变，s2拥有的是被clone的新数据的所有权

fn main() {
    let s1 = String::from("Hello");
    let s2 = s1.clone();
    println!("{}", s1);//Hello
    println!("{}", s2);//Hello
}

Copy trait 复制特质

  • 对于已知固定大小的数据类型，数据完全存储在stack中的类型，rust默认实现了Copy trait
  • 如果一个类型实现了Copy trait,那么变量绑定实际上是复制实际数据，旧变量依然可用
  • 如果一个类型或者该类型的一部分实现了Copy trait,那么Rust不允许再让它实现Copy trait
  • 任何简单标量的组合类型都实现了Copy trait
  • 任何需要分配内存或者某种资源的都不是Copy的

如：

integer:u8、i32
bool
char
float:f32、f64
Tuple:如果其中所有字段都是固定大小的可以Copy的，这个元组也是可以Copy的

所有权与函数

fn main(){
    let  s = String::from("Hello World");
    take_ownership(s);//move所有权，s失效，不可用
    let x= 5;
    makes_copy(x);//copy, 传入的是copy的值，不改变所有权
    println!("x:{}",x);//x:5

}
fn take_oenership(some_string:String){
    println!("{}",some_string);//Hello World
}//drop s
fn makes_copy(some_number:i32){
    println!("{}",some_number);//5
}

返回值与作用域

函数在返回值的过程中也会发生所有权转移

fn main() {
    let s1 = gives_ownership();//将world所有权move到s1
    println!("{}",s1);//world
    let s2 = String::from("hello");//变量s2绑定hello的所有权
    let s3 = takes_and_gives_back(s2);//将函数中返回的所有权move到s3，s2失效
    println!("{}",s3);//hello
}//drop s1、s3
fn gives_ownership() -> String {
    let some_string = String::from("world");//some_string绑定world的所有权
    some_string//返回world所有权
}
fn takes_and_gives_back(a_string: String) -> String {//s2的所有权move到函数中
    a_string//返回s2的所有权
}
  • 把一个值绑定给其他变量时就会发生move
  • 当一个包含heap数据的变量离开作用域时，它的值会被drop函数清理，除非数据的所有权move到另一个变量上了（包含heap数据的变量被move到另一个变量后原变量会失效，所以不用drop）

引用与借用

函数使用值但不获得所有权

fn main() {
    let s1 = String::from("hello"); //将hello绑定到s1
    let len = calculate_length(&s1); //引用s1但不move s1,move的是s1的引用
    println!("{}的长度为：{}", s1, len); //hello的长度为：5
}
fn calculate_length(s: &String) -> usize {//借用s1不获得所有权
    s.len() //返回s1的长度
}
  • 把引用作为函数参数叫借用

修改借用的值，借用时&mut

fn main() {
    let mut s1 = String::from("hello"); //将hello绑定到s1
    let len = calculate_length(&mut s1); //引用s1但不move s1,move的是s1的引用
    println!("{}的长度为：{}", s1, len); //hello,world的长度为：11
}
fn calculate_length(s:&mut String) -> usize {//借用s1不获得所有权
    s.push_str(",world");
    s.len() //返回s1的长度
}
  • 可变引用在同一作用域只能借用1次（避免数据竞争）
  • 不可变引用在同一作用域可以借用多次
  • 不可以在同一作用域同时借用一个可变引用和一个不可变引用

使用{}创建非同一作用域的可变引用

fn main() {
    let mut s = String::from("hello");
    {
        let s1 = &mut s; //借用可变引用s
        print_info(s1); //hello
    }
    let s2 = &mut s;//借用可变引用s
    print_info(s2); //hello
}
fn print_info(s: &mut String) {
    println!("{}", s);
}

slice切片

&str 字符串切片（String类型）

  • 字符串切片的范围索引必须发生在有效的UTF-8字符边界内
  • slice是对String类型数据的借用，不获得所有权
fn main() {
    let s = String::from("hello world");
    //slice
    let hello = &s[..5];
    let world = &s[6..11]; //或[6..]或[6..s.len()]
    println!("{},{}", hello, world); //hello,world
    //整个也是切片
    let whole = &s[0..s.len()]; //或[..]
    println!("{}", whole); //hello world
}

fn first_word(s: &str) -> &str{}

  • 使用在字符串切片直接调用该函数
  • 使用String类型，可以借用一个完整的切片调用该函数（函数可以被切片类型复用）
fn main() {
    let a_string = String::from("hello world");//String类型
    let wordIndex = first_world(&a_string[..]);//字符串切片
    println!("{}", wordIndex);//hello
    let b_string = "hello rust";//本质是切片&str
    let wordIndex = first_world(b_string);
    println!("{}", wordIndex);//hello
}
//遇到空格切片
fn first_world(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[..i];
        }
    }
    &s[..]
}

Array slice 数组切片

fn main(){
    let arry=[1,2,3,4,5,6];
    let slice = &arry[0..5];
    println!("{:?}",slice);//[1, 2, 3, 4, 5]
}

还可以对切片切片

fn main() {
    let arry = [1, 2, 3, 4, 5, 6];
    let slice = &arry[0..5];
    println!("{:?}", slice); //[1, 2, 3, 4, 5]

    let slice_of_slice = &slice[..2];
    println!("{:?}", slice_of_slice); //[1, 2]
}

Struct 结构体

  • struct是自定义的数据类型
  • 变量绑定顺序和声明的顺序可以不一样
#[derive(Debug)] //派生属性，Debug用来格式化输出值，顾名思义，debug用的
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let user1 = User {
        email: String::from("abc@outlook.com"),
        username: String::from("张三"),
        active: true,
        sign_in_count: 455,
    };
    println!("{:?}", user1); //User { username: "张三", email: "abc@outlook.com", sign_in_count: 455, active: true }
}
  • 一旦struct的实例是可变的，那么实例中的所有字段都是可变的
#[derive(Debug)] //派生属性，Debug用来格式化输出值，顾名思义，debug用的
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let mut user1 = User {
        email: String::from("abc@outlook.com"),
        username: String::from("张三"),
        active: true,
        sign_in_count: 455,
    };//绑定获得所有权
    //修改值
    user1.username = String::from("李四");//变量绑定新值所有权
    user1.active = false;
    println!("{:?}", user1); //User { username: "李四", email: "abc@outlook.com", sign_in_count: 455, active: false }
}//drop user1

字段和参数同名可简写

#[derive(Debug)] //派生属性，Debug用来格式化输出值，顾名思义，debug用的
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let user2 = User {
        email: String::from("abc@gmail.com"),
        username: String::from("张三"),
        active: true,
        sign_in_count: 000,
    };
    println!("{:?}", user2); //User { username: "张三", email: "abc@gmail.com", sign_in_count: 0, active: true }
}
fn build_user(email: String, username: String) -> User {
    User {
        email,    //等价于email:email,
        username, //等价于username:username,
        active: false,
        sign_in_count: 455,
    }
}

struct更新语法,创建部分字段相同的新实例，只需要更新不同的字段

#[derive(Debug)] //派生属性，Debug用来格式化输出值，顾名思义，debug用的
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let user2 = User {
        email: String::from("abc@gmail.com"),
        username: String::from("张三"),
        active: true,
        sign_in_count: 000,
    };
    println!("{:?}", user2); //User { username: "张三", email: "abc@gmail.com", sign_in_count: 0, active: true }

    let user3 = User {
        username: String::from("王五"),
        ..user2
    };
    println!("{:?}", user3); //User { username: "王五", email: "abc@gmail.com", sign_in_count: 0, active: true }
}
fn build_user(email: String, username: String) -> User {
    User {
        email,    //等价于email:email,
        username, //等价于username:username,
        active: false,
        sign_in_count: 455,
    }
}

Tuple struct 元组结构体

  • Tuple struct整体有名，字段无名
struct Color_RGB(u8,u8,u8)
fn main(){
    let blue = Color_RGB(0,111,255);
}

Unit-Like struct 无字段结构体

与()单元类型相似

struct Marker;

结构体与所有权

#[derive(Debug)] //派生属性，Debug用来格式化输出值，顾名思义，debug用的
struct Rectangle {
    width: u32,
    height: u32,
}
fn main() {
    let rect = Rectangle {
        width: 30,
        height: 50,
    }; //变量绑定
    println!("{}", area(&rect)); //1500
    println!("{:#?}",&rect);//Rectangle { width: 30, height: 50 }
}
fn area(rect: &Rectangle) -> u32 {//借用所有权
    rect.width * rect.height
}

解构

tuple解构

fn main() {
    let tuple = (1, "hello", 3.5);
    // 解构元组
    let (x, y, z) = tuple;
    println!("x: {}, y: {}, z: {}", x, y, z); //x: 1, y: hello, z: 3.5
}

struct解构

struct Point {
    x: i32,
    y: i32,
}
fn main() {
    let point = Point { x: 10, y: 20 };
    // 解构结构体
    let Point { x, y } = point;
    println!("x: {}, y: {}", x, y);//x: 10, y: 20
}

enum解构

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}
fn main() {
    let msg1 = Message::Move { x: 10, y: 20 };
    let msg2 = Message::Write(String::from("Hello, Rust!"));
    let msg3 = Message::ChangeColor(255, 0, 0);
    let msg4 = Message::Quit;

    match msg1 {
        Message::Move { x, y } => println!("Move to x: {}, y: {}", x, y),
        _ => (),//匹配失败返回单元类型
    }
    match msg2 {
        Message::Write(text) => println!("Write message: {}", text),
        _ => (),
    }
    match msg3 {
        Message::ChangeColor(r, g, b) => println!("Change color to r: {}, g: {}, b: {}", r, g, b),
        _ => (),
    }
    match msg4 {
        Message::Quit => println!("Quit message received"),
        _ => (),
    }
}

方法

  • 方法和函数类似:fn关键字、函数名、参数、返回值
  • 方法在struct（或enum、trait对象）的上下文定义
  • 方法第一个参数是(&self),表示调用方法的实例，也可以是可变借用(&mut self),也可以不使用借用直接获得所有权（self）
  • 在impl块里定义方法
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}
impl Rectangle {
    fn area(&self) -> u32 {//借用调用该方法的实例的所有权
        self.width * self.height
    }
}
fn main() {
    let rect = Rectangle {
        width: 30,
        height: 50,
    }; //变量绑定
    println!("{}", rect.area()); //1500
    println!("{:#?}", &rect); //Rectangle { width: 30, height: 50 }
}

方法签名

  • 在调用方法时，Rust会根据情况自动添加&，&mut，*(解引用)以便Object匹配方法的签名
struct Point {
    x: f64,
    y: f64,
}
fn distance(p1: &Point, p2: &Point) -> f64 {
    let dx = p2.x - p1.x;
    let dy = p2.y - p1.y;
    let squared_distance = dx * dx + dy * dy;
    squared_distance.sqrt()
}
fn main() {
    let mut point1 = Point { x: 0.0, y: 0.0 };
    let mut point2 = Point { x: 3.0, y: 4.0 };

    let mut dist = distance(&point1, &point2);
    println!("两点间的距离： {}", dist);//两点间的距离： 5
    //等价于
    println!("两点间的距离： {}",&dist);//两点间的距离： 5
    //等价于
    println!("两点间的距离： {}",*&dist);//两点间的距离： 5
    //等价于
    println!("两点间的距离： {}",&mut dist);//两点间的距离： 5
}

关联函数

  • 在impl块里定义不把self作为第一个参数的函数叫关联函数，如：String::from()
  • 关联函数常用于构造器
  • 每个struct允许拥有多个impl块
cci497
关注
  • 27
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Rust语言入门教程(八) - 引用与借用
因吹斯汀
11-27 817
上一章的内容中我们讨论了Rust的所有权系统，当我们不想移动值的所有权时，我们可以使用引用和借用，而这正是本章想要讨论的问题。
Rust语言入门教程(七) - 所有权系统
因吹斯汀
11-26 414
所有权系统是Rust敢于声称自己为一门内存安全语言的底气来源，也是让Rust成为一门与众不同的语言的所在之处。也正是因为这个特别的所有权系统，才使得编译器能够提前暴露代码中的错误，并给出我们必要且精准的错误提示。
Rust学习教程 - 引用与借用
Sunface撩技术
12-07 2495
引用与借用 上节中提到，如果仅仅是所有权转移，会让程序变得复杂，那能否像其它编程语言一样，使用某个变量的指针或者引用呢？答案是有的。 Rust通过借用(Borrowing)这个概念来达成上述的目的: 获取变量的引用，称之为借用(borrowing)。.
Rust 第三天---内存管理与所有权
shelgi的博客
07-05 925
到这里,对Rust的所有权特性应该有了大致的感受,和以往的编程语言不同,Rust对编译时格外严格以求运行时顺利.这对于开发者应该也是比较好的体验,看到顺利编译出可执行文件就可以放心下班而不用随时担心测出Bug然后慢慢trace去找Bug的原因.当然这也不是绝对的,毕竟机器之外我们还得与人打交道,哈哈哈.
Rust 所有权、引用与借用
weixin_61631200的博客
11-11 561
相比之下，在堆上分配内存则需要更多的工作，这是因为分配器必须首先找到一块足够存放数据的内存空间，并接着做一些记录为下一次分配做准备。可变引用有一个很大的限制：如果你有一个对该变量的可变引用，你就不能再创建对该变量的引用。Rust释放堆的方式为：对于某个值来说，当拥有它的变量走出作用范围时，内存会立即自动的交还给操作系统。x由于是i32类型实现了copy trait，往函数里传的是x的副本，x在第8行以后仍然是有效的。当变量离开作用域时，Rust会自动调用drop函数，并将变量使用的heap内存释放。
rust教程 第一章 —— 初识rust
热门推荐
余识-
04-22 2万+
本文主要的目的就是认识一下rust这门语言的基本概念
Rust中的所有权和借用规则详解
ArcherMarjo的博客
04-20 340
虽然这些规则增加了编程的复杂性，但它们为开发者提供了强大的保证，使他们能够编写出高效、可靠且易于维护的系统级代码。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。与不可变借用类似，可变借用也不会获取值的所有权，但在可变借用的生命周期内，我们不能创建其他引用（无论是可变还是不可变）到同一个值。这些规则虽然增加了编程的复杂性，但它们为Rust提供了强大的内存安全和并发安全保证。当一个变量被赋值时，它就获得了该值的所有权。
Rust 从入门到精通10-所有权
IT可乐
08-26 1146
在介绍rust 所有权时，我们先介绍内存管理的一些基础概念。
Rust 基础入门 —— 2.3.所有权和借用
ALex_zry的博客
08-21 1189
因为我们这里实际讲述的内容是关于 内存安全的，所以我们最好先复习一下内存的知识。然后我们，需要理解的就只有所有权概念，以及为了开发便利，进一步引出的引用借用概念。
rust视频教程-生命周期-4
05-09
rust视频教程-生命周期-4
rust视频教程-生命周期-3
05-09
rust视频教程-生命周期-3
rust视频教程-生命周期-2
05-09
rust视频教程-生命周期-2
rust视频教程-生命周期-1
05-08
rust视频教程-生命周期-1
rust示例教程rust-by-example
06-28
该文档系统展示了rust编程语法示例，是rust学习者必备文档。
【Rust光年纪】解锁Rust语言核心库奥秘：加密、数字签名和数据库操作全面解析
记录我的学习历程
07-20 1027
本文将介绍6个用于Rust语言的重要库，分别是ring、sodiumoxide、r2d2、sqlx、sled和mysql_async。这些库涵盖了加密、数字签名、数据库连接池、异步数据库驱动程序和嵌入式数据库等功能，为Rust开发者提供了丰富的选择。
Rust编程-模式匹配
最新发布
Mercuryyjs的博客
07-21 571
条件中的y就是来自表达式外部的y, 匹配守卫if n == y不是一个模式，所以它不会引入新的变量.能够比较n和y的值是否相同。组成：字面量、解体的数组、元组、枚举、结构体 、变量、通配符、占位符等组件组成。可以混用if let 、else if、else if let 、else。会匹配到第二个分支，这里的y在match创建的作用域内，是一个新的变量，不是x后面的y变量。可以使用使用_或..语法忽略元组中的元素，_只能匹配一个，.. 可以匹配多个。@运算符允许在测试一个值是否匹配模式的同时。
error: linking with `cc` failed: exit status: 1
orz_include的博客
07-18 345
去网上找了半天也解决不了问题，说是什么rustc或者cargo的问题，给我整不会了。然后搜了半天抱着试一下的态度尝试了这个帖子（使用pip安装pyd4时报错，然后修改用手动安装 ` ./setup install ` 结果还是不行，报错。）的方法，结果成功了，特此记录。
掌握Rust：函数、闭包与迭代器的综合运用
与墨的编程成长历程
07-21 983
在 Rust 中，函数是构成程序逻辑的基本单元，其定义简洁明了，支持参数、返回值类型声明，以及强大的模式匹配机制。模式匹配不仅限于match表达式，还广泛应用于函数参数，使得逻辑分支更加直观易懂。println!// 输出: Hello, Alice!println!// 输出: Hello, Bob!通过深入理解 Rust 中的函数、闭包与迭代器，我们不仅能够构建出逻辑清晰、易于维护的代码，还能在实践中提升数据处理的效率和程序的性能。
Rust编程指南：深入Rust-by-Example
"rust-by-example 是一份详细的 Rust 编程语言教程，旨在帮助学习者掌握 Rust 语言的核心概念和语法。教程通过丰富的示例来解释各个主题，涵盖从基础到高级的各种内容。" 在 Rust 语言中，学习者首先会接触到的是 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cci497

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值