rust的一点特点

rust安装
先在linux中安装工具包，具体参考https://www.rust-lang.org/zh-CN/tools/install
然后在IDE中，下载rust的插件包

```ruby
// fn main() {
//     println!("Hello World!");
//     let  num = 12;
// }

// /**
//   所有权和移动
//
//   因为变量要负责释放它们拥有的资源，所以资源只能拥有一个所有者。这也防止了 资源的重复释放。注意并非所有变量都拥有资源（例如引用）。
//
// 在进行赋值（let x = y）或通过值来传递函数参数（foo(x)）的时候，资源 的所有权（ownership）会发生转移。按照 Rust 的说法，这被称为资源 的移动（move）。
//
// 在移动资源之后，原来的所有者不能再被使用，这可避免悬挂指针（dangling pointer）的产生。
//  */
//
// fn main() {
//
//     let x = 5u32;
//     let y = x;
//     println!("x is {}, and y is {}", x, y);
//
//     // `a` 是一个指向堆分配的整数的指针
//     let a = Box::new(5i32);
//     println!("a contains: {}", a);
//
//
//     let b = a;
//     // 报错！`a` 不能访问数据，因为它不再拥有那部分堆上的内存。
//     // println!("a contains: {}", a);
//     println!("b contains: {}",b);
// }



// /**
//     可变性
//     当所有权转移时，数据的可变性可能发生改变。
//  */
//
// fn main() {
//
//     let immutable_box = Box::new(5u32);
//     println!("immutable_box contains {}", immutable_box);
//
//     // 可变性错误
//     // *immutable_box = 4;
//     // println!("immutable_box contains {}", immutable_box);
//
//     // *移动* box，改变所有权（和可变性）
//     let mut mutable_box = immutable_box;
//
//     println!("mutable_box contains {}", mutable_box);
//
//     // 修改 box 的内容
//     *mutable_box = 4;
//
//     println!("mutable_box now contains {}", mutable_box);
// }


// /**
//    借用
//    多数情况下，我们更希望能访问数据，同时不取得其所有权。为实现这点，Rust 使用 了借用（borrowing）机制。对象可以通过引用（&T）来传递，从而取代通过 值（T）来传递。
// 编译器（通过借用检查）静态地保证了引用总是指向有效的对象。也就是说，当存在 引用指向一个对象时，该对象不能被销毁。
// */
// // 此函数取得一个 box 的所有权并销毁它
// fn eat_box_i32(boxed_i32: Box<i32>) {
//     println!("Destroying box that contains {}", boxed_i32);
// }
//
// // 此函数借用了一个 i32 类型
// fn borrow_i32(borrowed_i32: &i32) {
//     println!("This int is: {}", borrowed_i32);
// }
//
// fn main() {
//     // 创建一个装箱的 i32 类型，以及一个存在栈中的 i32 类型。
//     let boxed_i32 = Box::new(5_i32);
//     let stacked_i32 = 6_i32;
//
//     // 借用了 box 的内容，但没有取得所有权，所以 box 的内容之后可以再次借用。
//     // 译注：请注意函数自身就是一个作用域，因此下面两个函数运行完成以后，
//     // 在函数中临时创建的引用也就不复存在了。
//     borrow_i32(&boxed_i32);
//     borrow_i32(&stacked_i32);
//
//     {
//         // 取得一个对 box 中数据的引用
//         let _ref_to_i32: &i32 = &boxed_i32;
//
//         // 报错！
//         // 当 `boxed_i32` 里面的值之后在作用域中被借用时，不能将其销毁。
//         // eat_box_i32(boxed_i32);
//         // let _ref_to_i32: &i32 = &boxed_i32;
//
//
//         // 在 `_ref_to_i32` 里面的值被销毁后，尝试借用 `_ref_to_i32`
//         //（译注：如果此处不借用，则在上一行的代码中，eat_box_i32(boxed_i32)可以将 `boxed_i32` 销毁。）
//         borrow_i32(_ref_to_i32);
//         // `_ref_to_i32` 离开作用域且不再被借用。
//     }
//
//     // `boxed_i32` 现在可以将所有权交给 `eat_i32` 并被销毁。
//     //（译注：能够销毁是因为已经不存在对 `boxed_i32` 的引用）
//          eat_box_i32(boxed_i32);
// }

// /**
//    可变数据可以使用 &mut T 进行可变借用。这叫做可变引用（mutable reference），它使借用者可以读/写数据。
// 相反，&T 通过不可变引用（immutable reference）来借用数据，借用者可以读数据而不能更改数据：
// */
// #[allow(dead_code)]
// #[derive(Clone, Copy)]
// struct Book {
//     // `&'static str` 是一个对分配在只读内存区的字符串的引用
//     author: &'static str,
//     title: &'static str,
//     year: u32,
// }
//
// // 此函数接受一个对 Book 类型的引用
// fn borrow_book(book: &Book) {
//     println!("I immutably borrowed {} - {} edition", book.title, book.year);
// }
//
// // 此函数接受一个对可变的 Book 类型的引用，它把年份 `year` 改为 2014 年
// fn new_edition(book: &mut Book) {
//     book.year = 2014;
//     println!("I mutably borrowed {} - {} edition", book.title, book.year);
// }
//
// fn main() {
//     // 创建一个名为 `immutabook` 的不可变的 Book 实例
//     let immutabook = Book {
//         // 字符串字面量拥有 `&'static str` 类型
//         author: "Douglas Hofstadter",
//         title: "Gödel, Escher, Bach",
//         year: 1979,
//     };
//
//     // 创建一个 `immutabook` 的可变拷贝，命名为 `mutabook`
//     let mut mutabook = immutabook.clone();
//
//     // 不可变地借用一个不可变对象
//     borrow_book(&immutabook);
//
//     // 不可变地借用一个可变对象
//     borrow_book(&mutabook);
//
//     // 可变地借用一个可变对象
//     new_edition(&mut mutabook);
//
//     // 报错！不能可变地借用一个不可变对象
//     // new_edition(&mut immutabook);
//
// }

// /**
//      冻结
// 当数据被借用时，它还会冻结（freeze）。已冻结的数据无法通过原始对象来修改，直到对这些数据的所有引用离开作用域为止。
// */
// fn main() {
//     let mut _mutable_integer = 7i32;
//
//     {
//         // 借用 `_mutable_integer`
//         let mut  large_integer = &_mutable_integer;
//
//         // 报错！`_mutable_integer` 在本作用域被冻结
//         // _mutable_integer = 50;
//
//         println!("Immutably borrowed {}", large_integer);
//
//         // `large_integer` 离开作用域
//     }
//
//     // 正常运行！`_mutable_integer` 在这作用域没有冻结
//     _mutable_integer = 3;
//     println!("_mutable_integer ={}",_mutable_integer)
// }






/**
别名使用
  数据可以进行多次不可变借用，但是在不可变借用的期间，原始数据不可进行可变借用。另 一方面，在同一时刻内只允许有一个可变借用。
只有在可变引用离开作用域之后，原始 数据才可再次被借用。
*/
struct Point { x: i32, y: i32, z: i32 }

fn main() {
    let mut point = Point { x: 0, y: 0, z: 0 };

    {
        let borrowed_point = &point;
        let another_borrow = &point;

        // 通过引用和原始所有者来访问数据
        println!("Point has coordinates: ({}, {}, {})",
                 borrowed_point.x, another_borrow.y, point.z);

        // 报错！不能可变地借用 `point` ，因为现在它有不可变的借用。
        // let mutable_borrow = &mut point;


        // 此处再次使用被借用的值
        println!("Point has coordinates: ({}, {}, {})", borrowed_point.x, another_borrow.y, point.z);

        // 不可变引用离开作用域
    }

    {
        let mutable_borrow = &mut point;

        // 通过可变引用来改变数据
        mutable_borrow.x = 5;
        mutable_borrow.y = 2;
        mutable_borrow.z = 1;

        // 报错！不能不可变地借用 `point`，因为现在它有可变的借用。
        // let y = &point.y;

        // 报错！不能打印，因为 `println!` 会创建一个不可变引用。
        // println!("Point Z coordinate is {}", point.z);


        // 可以工作！可变引用可以作为不可变的传给 `println!`。
        println!("Point has coordinates: ({}, {}, {})",
                 mutable_borrow.x, mutable_borrow.y, mutable_borrow.z);

        // 可变引用离开作用域
    }

    // 现在又可以不可变地借用 `point` 了。
    let borrowed_point = &point;
    println!("Point now has coordinates: ({}, {}, {})",
             borrowed_point.x, borrowed_point.y, borrowed_point.z);
}











// fn main() {}