Rust学习-阶段1学习总结

 　　我抽取下Key words，1. 每个人  2. 可靠且高效。“每个人”说明这门语言不会像面向machine的汇编或者C，应该具备现代语言的一些特性，泛型，反射，完善的函数库，好用的集合等等。可靠且高效，“可靠”就是说写出来的程序的漏洞会少，不会像C那样不检查下标越界，也不会产生一些常见的内存错误（doule free或者悬挂指针之类的）。当说到“高效”我想到了C++，大家都说C++的编译时间长且开发很慢（c++我没什么发言权，说的不对，诸君还请谅解），既然是高效，我想就不能仅仅是运行时间快了吧，开发时间也应该快。下面我们探讨一下我上面说的几点。

1. 变量和可变性

　　rust中变量默认是不可变的，也就是说下面的类似下面的赋值操作是非法的。

fn main() {
    let a = 100;
    a = 101;
}

　　会出现这样的错误，“不能给一个不可变的变量赋值两次。”

　　如果你需要一个“会变”的变量，那你需要用 mut 关键字去显式（explicitly）的声明一个变量。这么设计的原因，为什么我们需要显示的去声明一个变量为可变的？我也不知道，我猜测跟所有权有关？

fn main() {
    let mut a = 100;
    a = 101;
}

2.  函数的隐式返回值

　　    如果函数不适用return语句进行返回的话，函数隐式的返回最后一个表达式。当然这种写法是可以选装的，你可以选择传统的return版的返回语句。

fn add_one(num: i32)->i32 {
    num+1
}

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

3. 理解语句（statement）和表达式（expression）的区别

　　rust对于语句和表达式的区分比较严格，语句就是执行一些操作但并不产生结果的指令，表达式计算并产生一些值。

let mut num = 100;  //一个赋值语句
num = num + 1;  //语句
num + 1   //表达式

　　 函数调用是一个表达式。宏调用是一个表达式。我们用来创建新作用域的大括号（代码块），{}，也是一个表达式。

let y = {
    let x = 3;
    x+1
};

4.  break可以带变量

　　就下边那样，loop是rust中的循环，类似while(1)。　　

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

5.  元组

　　元组(tuple)类型是一个复合类型，它可以包含多种不同类型。这种类型的形式是 " (type1, type2, type3 ... ... ) "。

let tuple1 = (1, "hello", 3.14);
let tuple2: (i32, string, f32) = (1, "hello", 3.14);

　　那么怎么去获取元组的元素呢。可以通过元组的解构（destructuring），通过解构元组我们可以把元组内的值赋给其他的变量。

let (x, y, z) = tuple1;

　　也可以使用点号(".")去直接访问元组内的元素

let x = tuple1.0;
let y = tuple1.1;
let z = tuple1.2;

6.  所有权(ownership)

　　所有权是rust一个特点之一，也是rust内存管理的核心。每个值（可以理解是内存的一小块）都有一个所有者，这个所有者可以是变量。同时程序超出所有者的作用域时，所有者所有的值也会通过调用drop()函数，从而被释放。（注意drop不是通过运行时来调用的，而是在编译期就被插入了drop函数），这种做法类似于C++中的RAII机制。值得注意的是，所有权是可以被转移的，并且所有者在转移了值的所有权之后，他就会被rust认为是无效的所有者，再次使用该变量（所有者）会产生错误。

fn foo(str_cp:String) {
    println!("{}", str_cp);    
}

fn main() {
    let str1 = String::from("hello world");  
    foo(str1);                              
    println!("{}", str1);                
}

　　在上边的例子中，我们在堆上创建了一个字符串"hello world"，该字符串的所有者是变量str1，值得注意的是，将变量作为函数的形参也会转移值的所有权，因此我们当7行的函数调用返回时，str1已经是一个无效的所有者，可怜的str1，白白丢了自己的地盘，但是他也不是什么都没有收获的，这种所有权的转移，也是有好处的。

　　这里我生搬硬套了一种情况，尝试说明这种所有权转移的机制是如何防止double free的情况产生的。下面是一段和上述代码段类似的代码段，可以看到这里对同一内存块进行了两次free。那么rust是如何防止这种情况产生的呢？实际上在rust中17行的情况根本就不会出现，因为str1在此时已经是无效的了，没有free它的可能性。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void foo(char *str) 
{
    printf("%s\n", str);
    free(str);
}

int main(void) 
{
    while (1) {
        char *str1 = (char *)malloc(512);
        strncpy(str1, "hello world", 512);
        foo(str1);
        free(str1);  //double free
        printf("%s\n", str);
    }
    return 0;
}

　　就这样，本文只是我对前几天的学习进行的一个简单的总结。很多重要的东西都没有覆盖，等我的rust用的更熟练，我会尝试出一个Rust教程。Peace。

参考