文章目录
- 一、Rust的内存管理模型
-
- [1.GC（Stop the world）](#1.GC（Stop the world）)
- 2.C/C++内存错误大全
- 3.Rust的内存管理模型
- 二、String与&str
- 三、枚举与匹配模式
- 四、结构体、方法、关联函数、关联变量
- 五、Ownership与结构体
- 五、堆与栈、Copy与Move
- 参考
一、Rust的内存管理模型
Rust
- 所有权机制
- 引用称之为借用
1.GC（Stop the world）
"Stop the world"是与垃圾回收(Garbage Col lection)相关的术语，它指的是在进行垃圾回收时系统暂停程序的运行。
这个术语主要用于描述一种全局性的暂停，即所有应用线程都被停止，以便垃圾回收器能够安全地进行工作。这种全局性的停止会导致一些潜在的问题，特别是对于需要低延迟和高性能的应用程序。
需要注意的是，并非所有的垃圾回收算法都需要"stop the world'",有一些现代的垃圾回收器采用了一些技术来减小全局停顿的影响，比如并发垃圾回收和增量垃圾回收。
2.C/C++内存错误大全
cpp
1.内存泄漏(Memory Leaks)
int*ptr new int;
//忘记释放内存
/delete ptr:
2.悬空指针(Dangl ing Pointers)
int*ptr new int;
delete ptr;//ptr现在是悬空指针
3。重复释放(Double Free)
int*ptr new int;
delete ptr;
delete ptr;
4.数组越界(Array Out of Bounds
int arr [5];
arr[5]=10:
5.野指针(Memory Leaks)
int*ptr;
*ptr=10;/野指针
6.使用已经释放的内存(Use After Free)
int*ptr new int;
delete ptr;
*ptr=10;//使用已释放的内存
·7.堆栈溢出(Stack0 verflow）
递归堆栈溢出
·8.不匹配的new/delete或malloc,free3.Rust的内存管理模型
所有权系统(Ownership System)
借用(Bor rowing)
- 不可变引用（不可变借用）
- 可变引用（可变借用）
生命周期(Lifetimes)
引数计数(Reference Counting)
eg：
rust
fn get_length(s: String) -> usize {
println!("String: {}", s);
// 函数结束之后 main::s1也销毁了
s.len()
}
fn main() {
// copy move
// copy
let c1 = 1;
let c2 = c1;
println!("{}", c1);
let s1 = String::from("value");
// let s2 = s1;//所有权转移
let s2 = s1.clone(); // 深拷贝
// println!("{s1}"); // value borrowed here after move
println!("{}", s1);
let len = get_length(s1);
println!("{}", len);
let back = first_word("hello world");
println!("{}", back);
let back = first_word("we are the world");
println!("{}", back);
}
fn dangle() -> String {
"hello".to_owned()
}
// 静态的声明周期
// 不建议使用
fn dangle_static() -> &'static str {
"jdkfj"
}
// 传进来是引用，传出去也是引用
// String 与 &str，实际上就是vec u8的ref
fn first_word(s: &str) -> &str {
let bytes: &[u8] = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[0..i];
}
}
&s[..] //直接返回s也可以
}编译以及运行
bash
cargo run
Compiling ch5_ownership_introduce v0.1.0 (/home/wangji/installer/rust/project/ch5_ownership_introduce)
warning: unused variable: `c2`
--> src/main.rs:10:9
|
10 | let c2 = c1;
| ^^ help: if this is intentional, prefix it with an underscore: `_c2`
|
= note: `#[warn(unused_variables)]` on by default
warning: unused variable: `s2`
--> src/main.rs:14:9
|
14 | let s2 = s1.clone(); // 深拷贝
| ^^ help: if this is intentional, prefix it with an underscore: `_s2`
warning: function `dangle` is never used
--> src/main.rs:27:4
|
27 | fn dangle() -> String {
| ^^^^^^
|
= note: `#[warn(dead_code)]` on by default
warning: function `dangle_static` is never used
--> src/main.rs:33:4
|
33 | fn dangle_static() -> &'static str {
| ^^^^^^^^^^^^^
warning: `ch5_ownership_introduce` (bin "ch5_ownership_introduce") generated 4 warnings (run `cargo fix --bin "ch5_ownership_introduce"` to apply 2 suggestions)
Finished dev [unoptimized + debuginfo] target(s) in 0.37s
Running `target/debug/ch5_ownership_introduce`
1
value
String: value
5
hello
we二、String与&str
String,是一个堆分配的可变字符串类型
- 源码：
rust
pub struct String{
vec:Vec<u8>,
}- u8的可变数组
&str是指字符串切片引用，是在栈上分配的
- 字符串字面量
- 不可变引用，指向存储在其他地方的UTF-8编码的字符串数据
- 由指针和长度构成（由C++的角度去看）
1.String与&str如何选择
注意String是具有所有权的，而&str并没有
Struct中属性使用String
- 如果不使用显式声明生命周期，则无法使用&str
- 不只是麻烦，还有更多的隐患
函数参数推荐使用&str(如果不想交出所有权)
- &str为参数，可以传递&str和&String
- &String为参数，只能传递&String不能传递&str
2.Example
rust
struct Person<'a> {
name: &'a str, //'a的函数是name的生命周期和Person是一样的
color: String,
age: i32,
}
struct P2Persion {
name: String,
color: String,
age: i32,
}
//===================String 和 &str测试===================
// 可以传递的入参类型：&String， &str
fn print(data: &str) {
println!("{}", data);
}
//===================String 和 &str测试===================
// 可以传递的入参类型是：&String
fn print_string_borrow(data: &String) {
println!("{}", data);
}
fn main() {
//===================String 和 &str测试===================
// 从字面量&str转成String的三种方法：（1）String::from（2）to_string()（3）to_owned()
let name = String::from("Value C++");
let name_2 = "wangji".to_owned();
let course = "Rust".to_string();
// String有很多方法
let new_name = name.replace("C++", "CPP");
println!("{name_2} {name} {course} {new_name}");
//&str 能够直接进行ASICC编码
let rust = "\x52\x75\x73\x74"; // ascii
println!("{rust}");
//===================结构体测试===================
let pp = P2Persion {
name: "value".to_string(),
color: "green".to_string(),
age: 89,
};
//String &str
let color = "green".to_string();
let name = "John";
let people = Person {
name: name,
color: color,
age: 89,
};
// func
let value = "value".to_owned();
print(&value);
print("data");
// print_string_borrow("dd");
print_string_borrow(&value);
}编译及运行
bash
cargo run
warning: unused variable: `pp`
--> src/main.rs:41:9
|
41 | let pp = P2Persion {
| ^^ help: if this is intentional, prefix it with an underscore: `_pp`
|
= note: `#[warn(unused_variables)]` on by default
warning: unused variable: `people`
--> src/main.rs:50:9
|
50 | let people = Person {
| ^^^^^^ help: if this is intentional, prefix it with an underscore: `_people`
warning: fields `name`, `color`, and `age` are never read
--> src/main.rs:2:5
|
1 | struct Person<'a> {
| ------ fields in this struct
2 | name: &'a str, //'a的函数是name的生命周期和Person是一样的
| ^^^^
3 | color: String,
| ^^^^^
4 | age: i32,
| ^^^
|
= note: `#[warn(dead_code)]` on by default
warning: fields `name`, `color`, and `age` are never read
--> src/main.rs:8:5
|
7 | struct P2Persion {
| --------- fields in this struct
8 | name: String,
| ^^^^
9 | color: String,
| ^^^^^
10 | age: i32,
| ^^^
warning: `ch2_string_str` (bin "ch2_string_str") generated 4 warnings
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
Running `target/debug/ch2_string_str`
wangji Value C++ Rust Value CPP
Rust
value
data
value三、枚举与匹配模式
枚举（enums)是一种用户自定义的数据类型，用于表示具有一组离散可能值的变量
- 每种可能值都称为"variant"(变体)
- 枚举名：变体名
枚举的好处
- 可以使你的代码更严谨、更易读
- More robust programs
rust
enum Shape{
Circle(f64)
Rectangle(f64,f64),
Square (f64)
}1.常见的枚举类型：Option和Result
rust
pub enum Option<T>{
None,
Some (T),
}
pub enum Result<T,E>{
Ok(T)
Err (E),
}2.匹配模式
1.match关键字实现
2.必须覆盖所有的变体
3.可以用_、，...=、三元(if)等来进行匹配
rust
match number{
0 => printIn!("Zero"),
1|2 => printIn!("One or Two"),
3..=9 => printIn!("From Three to Nine"),
n if n%2 ==0 =>printIn!("Even number"),
_=printIn!("Other"),
}eg：
rust
use std::collections::btree_set::Union;
enum Color {
Red,
Yellow,
Blue,
}
fn print_color(my_color: Color) {
match my_color {
Color::Red => println!("Red"),
Color::Yellow => println!("Yellow"),
Color::Blue => println!("Blue"),
}
}
enum BuildingLocation {
Number(i32),
Name(String), // 不用&str
Unknown,
}
// rust是面向函数，面向行为
// rust：不能把行为写在struct里面，与C++不同
impl BuildingLocation {
fn print_location(&self) {
match self {
// BuildingLocation::Number(44)
BuildingLocation::Number(c) => println!("building number {}", c),
// BuildingLocation::Name("ok".to_string())
BuildingLocation::Name(s) => println!("building name {}", *s),
BuildingLocation::Unknown => println!("unknown"),
}
}
}
fn main() {
let a = Color::Red;
print_color(a);
// let b = a;所有权已经转移到print_color里面了
let house = BuildingLocation::Name("fdfd".to_string());
house.print_location();
let house = BuildingLocation::Number(1);
house.print_location();
let house = BuildingLocation::Unknown;
house.print_location();
}编译及运行：
bash
cargo run
Compiling ch7_enum v0.1.0 (/home/wangji/installer/rust/project/ch7_enum)
warning: unused import: `std::collections::btree_set::Union`
--> src/main.rs:1:5
|
1 | use std::collections::btree_set::Union;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_imports)]` on by default
warning: variants `Yellow` and `Blue` are never constructed
--> src/main.rs:5:5
|
3 | enum Color {
| ----- variants in this enum
4 | Red,
5 | Yellow,
| ^^^^^^
6 | Blue,
| ^^^^
|
= note: `#[warn(dead_code)]` on by default
warning: `ch7_enum` (bin "ch7_enum") generated 2 warnings (run `cargo fix --bin "ch7_enum"` to apply 1 suggestion)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 6.46s
Running `target/debug/ch7_enum`
Red
building name fdfd
building number 1
unknown四、结构体、方法、关联函数、关联变量
结构体间接
- 结构体是一种用户定义的数据类型，用于创建自定义的数据结构。
rust
struct Point{
x:i32,
y:i32,
}- 每条数据(x和y)称为属性（字段field)
- 通过点(.)来访问结构体中的属性
结构体中的方法
- 在rust中都称之为关联函数，这里为了方便称之为方法了
- 这里的方法是指，通过实例调用(&self、&mut self、self)
- &self。引用
- &mut self，可变self的引用
- self，交出所有权
rust
impl Point
fn distance (&self,other:&Point)->f64{
let dx = (self.x - other.x)as f64;
let dy = (self.y - other.y)as f64;
(dx*dx + dy*dy).sqrt()
}结构体中的关联函数
- 关联函数是与类型相关的函数，调用时为结构体名::函数名
- Self 就是Point，结构体的名字
rust
impl Point{
fn new(x: u32, y:u32) ->self{
Point{x,y}
}
}结构体中的关联变量
- 这里的关联变量是指，和结构体类型相关的变量，也可以在特质或是枚举中
rust
impl Point{
const Pl:f64=3.14;
}- 调用时使用Point::Pl
eg：
rust
enum Flavor {
Spicy,
Sweet,
Fruity,
}
struct Drink {
flavor: Flavor,
price: f64,
}
impl Drink {
// 关联变量
const MAX_PRICE: f64 = 10.0;
// 方法,&self不能修改里面的成员
// Drink::MAX_PRICE,等价写法Self::MAX_PRICE
fn buy(&self) {
if self.price > Drink::MAX_PRICE {
println!("I am poor");
return;
}
println!("buy it");
}
// 关联函数
// Self表示返回Drink结构体
fn new(price: f64) -> Self {
Drink {
flavor: Flavor::Fruity,
price,
}
}
}
fn print_drink(drink: Drink) {
match drink.flavor {
Flavor::Fruity => println!("fruity"),
Flavor::Spicy => println!("spicy"),
Flavor::Sweet => println!("sweet"),
}
println!("{}", drink.price);
}
fn main() {
let sweet = Drink {
flavor: Flavor::Sweet,
price: 6.0,
};
println!("{}", sweet.price);
print_drink(sweet); // sweet 已经被销毁了
// print_drink(sweet);
let sweet = Drink::new(12.0);
sweet.buy();
}编译及运行：
bash
cargo run
Compiling ch8_struct v0.1.0 (/home/wangji/installer/rust/project/ch8_struct)
warning: variant `Spicy` is never constructed
--> src/main.rs:2:5
|
1 | enum Flavor {
| ------ variant in this enum
2 | Spicy,
| ^^^^^
|
= note: `#[warn(dead_code)]` on by default
warning: `ch8_struct` (bin "ch8_struct") generated 1 warning
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.32s
Running `target/debug/ch8_struct`
6
sweet
6
I am poor五、Ownership与结构体
Ownership Rules
- 1.Each value in Rust has an owner
- 2.There can only be one owner at a time
- 3.Values are automatically dropped when the owner goes out of scope
Value Passing Semantics值传递语义
每当将值从一个位置传递到另一个位置时，borrow checker:都会重新评估所有权。
- 1.Immutab|e Borrow使用不可变的借用，值的所有权仍归发送方所有，接收方直接接收对该值的引用，而不是该值的副本。但是，他们不能使用该引用来修改它指向的值，编译器不允许这样做。释放资源的责任仍由发送方承担。仅当发件人本身超出范围时，才会删除该值
- 2.Mutable Borrow使用可变的借用所有权和删除值的责任也由发送者承担。但是接收方能够通过他们接收的引用来修改该值。
- 3.Move这是所有权从一个地点转移到另一个地点。borrow checker关于释放该值的决定将由该值的接收者（而不是发送者）通知。由于所有权已从发送方转移到接收方，因此发送方在将引用移动到另一个上下文后不能再使用该引用，发送方在移动后对v|aue的任何使用都会导致错误。
结构体中关联函数的参数
rust
&self
对应的，在函数参数中：(self:&Self)
不可变引用
&mut self
对应的，在函数参数中(self:&mut Self)
可变引用
self
对应的，在函数参数中(self:Self)
Move
impl Point{
get (self:Self)->i32{
self.x
}
}Example：
rust
struct Counter {
number: i32,
}
impl Counter {
fn new(number: i32) -> Self {
Self { number }
}
// 不可变借用
fn get_number(&self) -> i32 {
self.number
} // Counter::get_number(self: &Self)
// 不可变借用
fn add(&mut self, increment: i32) {
self.number += increment;
} // Counter::add(self: &mut Self, increment:)
// move
fn give_up(self) {
println!("free {}", self.number);
}
/**
等价于下面的写法
fn combine(c1: Self, c2: Self) -> Self {
return Self {
number: c1.number + c2.number,
};
}
*/
fn combine(c1: Self, c2: Self) -> Self {
Self {
number: c1.number + c2.number,
}
}
}
fn main() {
let mut c1 = Counter::new(0);
println!("c1 number {}", c1.get_number());
println!("c1 number {}", c1.get_number());
c1.add(2);
println!("c1 number {}", c1.get_number());
println!("c1 number {}", c1.get_number());
c1.give_up();
// println!("c1 number {}", c1.get_number());
let c1 = Counter::new(2);
let c2 = Counter::new(1);
let c3 = Counter::combine(c1, c2);
// println!("c1 number {}", c1.get_number());
// println!("c2 number {}", c2.get_number());
println!("c3 number {}", c3.get_number());
}编译及运行：
bash
cargo run
Compiling ch9_ownership_struct v0.1.0 (/home/wangji/installer/rust/project/ch9_ownership_struct)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 4.31s
Running `target/debug/ch9_ownership_struct`
c1 number 0
c1 number 0
c1 number 2
c1 number 2
free 2
c3 number 3五、堆与栈、Copy与Move
1.堆与栈
stack
- 1.堆栈将按照获取值的顺序存储值，并以相反的顺序删除值
- 2.操作高效，函数作用域就是在栈上
- 3.堆栈上存储的所有数据都必须具有已知的固定大小数据
heap
- 1.堆的规律性较差，当你把一些东西放到你请求的堆上时，你请求，请求空间，并返回一个指针，这是该位置的地址
- 2.长度不确定
2.Box智能指针
Box是一个智能指针，它提供对堆分配内存的所有权。它允许你将数据存储在堆上而不是栈上，并且在复制或移动时保持对数据的唯一拥有权。使用Bo×可以避免一些内存管理问题，如悬垂指针和重复释放。
- 1.所有权转移
- 2.释放内存
- 3.解引用
- 4.构建递归数据结构
3.Copy与Move
Move:所有权转移
Clone:深拷贝
Copy:Copy是在CIone的基础建立的marker trait(Rust中最类似继承的关系)
- 1.trait(特质)是一种定义共享行为的机制。Clone也是特质
- 2 marker trait（标记特质）是一个没有任何方法的trait，他主要用于向编译期传递某些信息，以改变类型的默认行为
4.小结
stack
- 1.基础类型
- 2.tuple和array
- 3.struct与枚举等也是存储在栈上，如果属性有String等在堆上的数据类型会有指向堆的
heap
- Box Rc String/Vec等
一般来说在栈上的数据类型都默认是copy的，但是struct等默认为move，需要Copy只需要设置数据类型实现Copy特质即可，或是调用CIone函数（需要实现CIone特质)
box Example：
rust
struct Point {
x: i32,
y: i32,
}
fn main() {
let boxed_point = Box::new(Point { x: 10, y: 20 });
println!("x:{}, y:{}", boxed_point.x, boxed_point.y);
let mut boxed_point = Box::new(32);
println!("{}", *boxed_point);
*boxed_point += 10;
println!("{}", *boxed_point);
}编译及运行：
bash
cargo run
Compiling ch10_box v0.1.0 (/home/wangji/installer/rust/project/ch10_box)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 9.43s
Running `target/debug/ch10_box`
x:10, y:20
32
42copy and move Example：
rust
#[derive(Debug, Clone, Copy)]
struct Book {
page: i32,
rating: f64,
}
fn main() {
let x = vec![1, 2, 3, 4];
let y = x.clone();
println!("{:#?}", y);
println!("{:?}", x);
let x = "ss".to_string();
let y = x.clone();
println!("{:?}", x);
let b1 = Book {
page: 1,
rating: 0.1,
};
let b2 = b1; // copy
println!("{}", b1.page);
println!("{:?}", b2);
}编译及运行：
bash
cargo run
warning: unused variable: `y`
--> src/main.rs:14:9
|
14 | let y = x.clone();
| ^ help: if this is intentional, prefix it with an underscore: `_y`
|
= note: `#[warn(unused_variables)]` on by default
warning: field `rating` is never read
--> src/main.rs:4:5
|
2 | struct Book {
| ---- field in this struct
3 | page: i32,
4 | rating: f64,
| ^^^^^^
|
= note: `Book` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis
= note: `#[warn(dead_code)]` on by default
warning: `ch10_copy_move` (bin "ch10_copy_move") generated 2 warnings
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s
Running `target/debug/ch10_copy_move`
[
1,
2,
3,
4,
]
[1, 2, 3, 4]
"ss"
1
Book { page: 1, rating: 0.1 }