于是这一篇学习笔记就以注意点的方式来写好了～

1. 变量默认都是 immutable
2. 一些基本数据类型
3. 函数、控制流
4. Ownership
5. 引用
6. Slices
7. 结构体

1. 变量默认都是 immutable

首先 Rust 中定义变量默认都是 immutable 的，如果想要之后修改变量的值的话，粗略来说有 2 种方式（实际上其实是 1 种）

第 1 种则是在声明变量时添加修饰符 mut，第 2 种是再次声明一个同名变量，将之前的 shadow 掉。当然，第 2 种其实并没有真正修改前一个变量在内存中的值，所以站在内存的角度来看，只有前一种方法才算真正修改了。

fn main() {
    let p = 100;
    println!("p = {}", p);
    p = 101; // 这里会报错
    println!("p = {}", p);
}

可以看到 rustc 给我们的建议是给变量 p 增加修饰符 mut，即

fn main() {
    let mut p = 100;
    println!("p = {}", p);
    p = 101;
    println!("p = {}", p);
}

当然也可以使用第二种方法～Shadow

fn main() {
    let mut p = 100;
    println!("p = {}", p);
    let p = 101;
    println!("p = {}", p);
}

这里第二次声明变量 p 的时候，实际上是把第一个变量 p 给 shadow 掉了，类似于 C/C++ 中局部变量 shadow 掉全局变量一样w 而实际上被 shadow 的那个变量在内存中的值并没有改变

不过需要注意的是，声明为了 mutable 之后，该变量的类型就不可发生改变了（除非再次被 shadow 成别的）；但是第二种 shadow 的话，变量的类型是可以发生改变的

fn main() {
    let p = "string";
    println!("p = {}", p);

    let mut p = 100;
    println!("p = {}", p);

    // mutable 只是值可以发生变化
    // 并非表示弱类型
    p = "error";
    println!("p = {}", p);
}

2. 一些基本数据类型

这个好像没有太多可以记笔记的，，，

对于整数来说，前缀 i 代表有符号数，前缀 u 则为无符号数。Rust 中整数的有如下类型（下表来源：https://doc.rust-lang.org/book/ch03-02-data-types.html）

Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
arch	isize	usize

最后一个 arch 则是根据编译时的操作系统是 64 位还是 32 位来决定的

浮点数就很简单了，要么单精度 f32，要么双精度 f64

然后还有一个 bool 类型，这个是必然的

最后就是 Tuple 和 Array 了～Array 跟 Python 中的写法几乎是一样的～Tuple的话，略有一点不同，在取其中一个的时候，可以通过如下方式

fn main() {
    let t = ("Hello", 233, 1.3);
    println!("{}", t.2);
}

3. 函数、控制流

说实话，函数的写法的话，几乎跟 Swift 没有多大的区别，if、for、loop、while 也都是大同小异，让我觉得 Rust 里这部分比较值得一提的是，可以用 break 返回一个值到循环体外

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 5 {
            break counter * 10;
        }
    };
    println!("result is {}", result);
}

4. Ownership

简单来说，对于堆上的对象，=(Assign) 默认是传引用，对于栈上的数据，则都是复制值。

如果要 deep copy 一个堆上的对象，可以使用 .clone() 方法（或者自己实现）

对象默认在函数间传递时，会将其 ownership 一同传递。

fn main() {
    // s 对象在堆上被申请
    let s = String::from("hello");

    // s 的值与其 ownership 移动到了函数中
    takes_ownership(s);

    // 因此 s 在那之后不再有效
    // 下面一行会报错
    println!("s is gone... {}", s);
}

fn takes_ownership(some_string: String) { // some_string 开始的作用域
    println!("{}", some_string);
} // some_string 在此处离开作用域
  // `drop` 被调用
  // some_string 被释放

当然，ownership 既可以被拿走，也可以从别处被给予～

fn main() {
    // s1 对象在堆上被申请
    let s1 = String::from("hello");

    // s1 的值与其 ownership 移动到了函数中
    // 而这个函数又将其结果的 ownership 给回了 s2
    let s2 = takes_and_gives_back(s1);

    // 因此 s1 在那之后不再有效
    // 但 s2 是有效的
    println!("s2 is {}", s2);
}

fn takes_and_gives_back(some_string: String) -> String { // some_string 开始的作用域
    some_string
} // some_string 被返回
  // 其值与 ownership 也被返回

5. 引用

总是传递值与 ownership 也是很麻烦的，因此 Rust 里也是可以传引用的，简单来说，与 C++ 类似，只需要加上 & 即可～当然 Rust 不是 C++，只用 & 的话，传的其实是 immutable 的引用

fn main() {
    let s = String::from("hello");
    change(&s);
}

fn change(some_string: &String) {
    // immutable!
    some_string.push_str(", world");
}