Rust advanced ownership - memory management

1. introduction

In the previous article , We introduced Rust The ownership of the ：

Rust The ownership mechanism

Ownership mechanism Rust It can conveniently realize the automatic recycling of memory , however Rust How to divide and manage memory ？ This article will introduce .

2. Memory allocation -- Heap and stack

Like many other languages ,Rust The memory is also divided into heap and stack . because Rust Language is a system level programming language , In the process of writing, we must know whether the memory is allocated to heap space or stack space , But usually , Placing data on the stack is not called “ Distribute ”, It is “ Push the ”.

stay Rust in , Only data of fixed size known at compile time will be allocated in stack space , Data that cannot be sized at compile time , Can only be placed in heap space .

For example ,Rust There are two types of strings in ：

// &str  type 
let str1 = "hello world!";
// String  type 
let str2 = String::from("hello");

Copy

str1 yes &str type , Its value is fixed in size and immutable in content , He can already determine the size of the memory used at compile time , therefore ,str1 Will be pushed onto the stack .

str2 yes String type , This is a kind of Rust The packaging type of , It is a variable string type , for example , You can use the following methods to str2 Add new content ：

str2.push_str(" world!");

Copy

therefore ,String Type of str2 Is allocated in heap space , For all that , actually , A structure will still be pushed into the stack space , Used to hold pointers to heap space 、 The amount of heap space allocated this time , And used length .

3. Memory release

Because heap space is dynamically allocated at runtime , So like many other languages , Heap space cleaning is also an issue we need to consider ,Rust The ownership mechanism of has solved this problem to a great extent .

When a variable is out of scope , According to the ownership mechanism ,Rust Will automatically call a file named drop The special function of , In this function ,Rust Will release all memory that is not being used anymore .

In the previous article , We introduced Rust Of “ Move ” Mechanism , In a nutshell , For the basic type , When a variable is assigned to another variable ,Rust Will open up a new space in the stack space for new variables , Make a copy of the original value , This makes both variables available in the current scope , here “ Basic data type ” Only include ：

1. All integer types , Include symbols 、 Unsigned type , Such as u32、i64 etc. ;
2. Boolean type bool;
3. Character type char.

For data allocated in heap space , When a variable is assigned to another variable ,Rust Will destroy the original variable , Ownership of the data is Move To the new variable .

Why is this difference ？ Suppose you keep a copy of the variable contents pointing to the data in the heap space and give it to the new variable , Then there will be a case where the heap data is pointed to by two pointers . When two variables exit the scope ,Rust You must decide how many times you want to release the heap data , And in this case , Modifying a variable means that the actual data pointed to by another variable has been modified , The behavior is still different from the base type . in fact , The best solution is to replicate the data in the heap space synchronously , In many other languages “ Deep copy ”, However, the performance will be greatly affected . therefore , After weighing ,Rust adopt “ Move ” To realize the assignment of heap space variables .