所有者

程序的内存可以按以下方式分配 −

• 堆栈
• 堆

堆栈

堆栈遵循后进先出的顺序。 堆栈存储其大小在编译时已知的数据值。 例如，固定大小 i32 的变量是堆栈分配的候选者。 它的大小在编译时是已知的。 所有标量类型都可以存储在堆栈中，因为大小是固定的。

考虑一个字符串示例，它在运行时被分配一个值。 此类字符串的确切大小无法在编译时确定。 因此它不是堆栈分配的候选者，而是堆分配的候选者。

堆

堆内存存储编译时大小未知的数据值。 它用于存储动态数据。 简单地说，堆内存被分配给在程序的整个生命周期中可能发生变化的数据值。 堆是内存中的一个区域，与堆栈相比，它的组织性较差。

什么是所有者?

Rust 中的每个值都有一个变量，称为值的所有者。 Rust 中存储的每个数据都会有一个与其关联的所有者。 例如，在语法中 − let age = 30, age 是值 30 的所有者。

• 每个数据一次只能有一个所有者。

• 两个变量不能指向同一内存位置。 变量将始终指向不同的内存位置。

转让所有者

价的所有者可以通过以下方式转移: −

• 将一个变量的值分配给另一个变量。

• 将值传递给函数。

• 从函数返回值。

将一个变量的值赋给另一个变量

Rust 作为一种语言的主要卖点是它的内存安全性。 内存安全是通过严格控制谁可以使用什么以及何时限制来实现的。

考虑以下代码片段 −

fn main(){
   let v = vec![1,2,3]; 
   // 向量 v 拥有堆中的对象

   // 在任何给定时间只有一个变量拥有堆内存
   let v2 = v; 
   // 这里两个变量拥有堆值，
   // Rust 中不允许两个指向相同内容的指针

   //Rust 在内存访问方面非常聪明，因此它可以检测竞争条件
   //因为两个变量指向同一个堆

   println!("{:?}",v);
}

上面的示例声明了一个向量 v。所有者的想法是只有一个变量绑定到资源，v 绑定到资源或 v2 绑定到资源 。 上面的例子抛出一个错误 − use of moved value: `v`。这是因为资源的所有者已转移到 v2。 这意味着所有者从 v 转移到 v2 (v2=v)，转移后 v 失效。

将值传递给函数

当我们将堆中的对象传递给闭包或函数时，值的所有者也会发生变化。

fn main(){
   let v = vec![1,2,3];     // 向量 v 拥有堆中的对象
   let v2 = v;              // 将所有者移至 v2
   display(v2);             // v2 移至显示且 v2 失效
   println!("In main {:?}",v2);    // v2 在这里不再可用
}
fn display(v:Vec){
   println!("inside display {:?}",v);
}

从函数返回值

传递给函数的所有者将在函数执行完成后失效。 解决此问题的一种解决方法是让函数将拥有的对象返回给调用者。

fn main(){
   let v = vec![1,2,3];       // 向量 v 拥有堆中的对象
   let v2 = v;                // 将所有者移至 v2
   let v2_return = display(v2);    
   println!("In main {:?}",v2_return);
}
fn display(v:Vec)->Vec { 
   // 返回相同的向量
   println!("inside display {:?}",v);
}

所有者和原始类型

对于基本类型，一个变量的内容被复制到另一个变量。 因此，没有发生所有者转移。 这是因为原始变量比对象需要更少的资源。 考虑下面的例子 −

fn main(){
   let u1 = 10;
   let u2 = u1;  // u1 值复制（未移动）到 u2

   println!("u1 = {}",u1);
}

输出将为 – 10。