Rust编程语言三

fn main() 
    // 所有权规则   变量作用域
    // 变量范围是变量的一个属性，其代表变量的可行域，默认从声明变量开始有效直到变量所在域结束。
    // 这里未创建 变量 s 此时 s 不可用
    let s = "abc"; // 这里创建了变量 s 此时 s 可以使用
                   // 这里 变量 s 是可用的
    println!(" s  = ", s);
    my_test_string();
    heap_test();
    move_clone_test();
    ownership_and_functions();
    return_value_and_scope();

// 这里  外面 变量 s 不可用
///
/// String 类型
///
fn my_test_string() 
    //let s = String::from("hello");// 不可变 string 变量
    let mut s = String::from("hello"); // 创建一个可变的string变量
    s.push_str(" word"); // push_str() 在字符串后追加字面值
    println!("my_test >>  s = ", s);


///
/// 内存分配
///
fn heap_test() 
    let num = 1; // 栈内存  创建变量并赋值时 变量有效
    let num2 = 1.1; // 栈内存  创建变量并赋值时 变量有效
    let str1 = "asd"; // 栈内存  创建变量并赋值时 变量有效
    let str2 = String::from("qwe"); // 堆内存  创建变量并赋值时 变量有效
    println!(
        " num = ,num2 = ,str1 = ,str2 = ",
        num, num2, str1, str2
    );

// 上面函数 中的变量全部失效 被自动回收
///
/// 变量的 移动 克隆
///
fn move_clone_test() 
    // 堆内存中的值无法复制只能移动  基本数据类型可以复制
    let a = String::from("abc"); // 创建变量 a 赋值 string 类型 字符串abc
    let b = a; // 将 变量 a 赋值给 b 实际是将变量a的值移动到b ， 此时 变量a 失效
    println!("b = ", b);
    //println!("a = ", a); // 此处报错 a 被移动到b时a 失效了
    // clone 克隆
    let s1 = String::from("hello"); // 创建变量s1 赋值 string类型 字符串hello
    let s2 = s1.clone(); // 将 s1的值克隆给s2 此时是克隆所以 s1仍然存在且有效
    println!("s1 = , s2 = ", s1, s2); // 打印 s1 s2值


///
/// 所有权与函数
///
fn ownership_and_functions() 
    let s = String::from("hello"); // s 进入作用域 s 是string类型 存储在堆内存中不能被复制
    takes_ownership(s); // s 的值移动到函数里 ...
                        // ... 所以到这里不再有效
    let x = 5; // x 进入作用域
    makes_copy(x); // x 应该移动函数里，
                   // 但 i32 是 Copy 的，所以在后面可继续使用 x
 // 这里, x 先移出了作用域，然后是 s。但因为 s 的值已被移走，
  // 所以不会有特殊操作
///
/// 移动所有权
///
fn takes_ownership(some_string: String) 
    // some_string 进入作用域
    println!("", some_string);
 // 这里，some_string 移出作用域并调用 `drop` 方法。占用的内存被释放
///
/// 复制
///
fn makes_copy(some_integer: i32) 
    // some_integer 进入作用域
    println!("", some_integer);
 // 这里，some_integer 移出作用域。不会有特殊操作
///
/// 返回值与作用域
///
fn return_value_and_scope() 
    let s1 = gives_ownership(); // gives_ownership 将返回值
                                // 移给 s1

    let s2 = String::from("hello"); // s2 进入作用域

    let s3 = takes_and_gives_back(s2); // s2 被移动到
                                       // takes_and_gives_back 中,
                                       // 它也将返回值移给 s3
    println!("s3 = ", s3);
 // 这里, s3 移出作用域并被丢弃。s2 也移出作用域，但已被移走，
  // 所以什么也不会发生。s1 移出作用域并被丢弃

fn gives_ownership() -> String 
    // gives_ownership 将返回值移动给
    // 调用它的函数
    let some_string = String::from("hello"); // some_string 进入作用域.
    some_string // 返回 some_string 并移出给调用的函数


// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String 
    // a_string 进入作用域
    a_string // 返回 a_string 并移出给调用的函数

输出

 s  = abc
my_test >>  s = hello word
 num = 1,num2 = 1.1,str1 = asd,str2 = qwe
b = abc
s1 = hello, s2 = hello
hello
5
s3 = hello

进程已结束，退出代码为 0

我是Mr-老鬼、QQ1156346325 。交流QQ群：620028786，647082990，772810035
————————————————版权声明——————————————————
本文版权所有~Mr-老鬼 ~转载请注明原文地址
免责声明：本文所有的教程仅限交流学习使用不得用于违法用途，造成的法律后果本人不承担责任。