20240225Rust学习笔记

cargo build 编译并构建可执行文件

cargo run 编译并构建可执行文件，并且执行该程序

cargo check 只编译并不产生可执行文件，速度比build/run都快

cargo build --release 编译并构建可执行文件，同时发布

      代码会运行的更快，但是编译的时间会更长

let mut 声明可变变量,rust默认是不可变量,只能赋值一次,加了mut后可以多次赋值

const 声明常量,大写,可以在外部,也可以在函数内部声明,不能改

i32 f64 默认类型,

shadow机制,同名变量重新赋值可以变不同的类型

cargo update 更新cargo.toml文件中的提及的库

cargo doc --open 下载你本地使用的库文件对应的文档并用浏览器打开

常量为什么不能是指定运行时才有返回值的呢,因为它要在编译的时候就将表达式的值计算出来,如果是运行时类的结果会报错,也是为了提高安全性

shadowing的特性原因,是因为rust的变量默认是不可变的,当你第二次用let的时候,它之前的就消失了.也是为了安全性考虑,但是目前没看到为啥有这样做的必要,

重新定义一个变量是最好的

rust 整数默认类型为u32,无符号32位整型,浮点类型为u64,无符号64位浮点型

rust move机制,复杂类型的数据同一时间只有一个人拥有,只有一个王,用完了之前的就不能再用了.会默认执行drop方法,回收内存.

如果你想深度copy,那么就需要使用到clone方法.

而整型等具在编译时就有确定大小的量是存在于栈内存中.

reference的方式 &test_str 传递引用,而不传递所有权.可以方便函数中使用,也不会让函数调用drop函数,把当前变量清除.

而reference的借用方式不能修改变量值,因为rust的变量默认是不可变的,如果需要修改,原先的变量需要增加mut的关键词,同时借用的引用也需要增加mut关键词.

同时一个可变引用变量不能同时被两次借用,会报错的.

use std::io;

fn main() {

    //while_loop_test();

    let range_result:i32 = for_range_test(16,20);

    println!("the sum from 16 to 20 is: {}",range_result);

    string_test();

    let first_str =String::from("hello");

    take_ownership(first_str.clone());//String 是复杂类型,传递出去之后first_str的所有权就没有了,而如果使用clone,说明又复制了一份数据,原来的还可以用

    println!("{}",first_str);

    let test_str = give_ownership_in_fn();

    println!("{}",test_str);

    let origin_str = String::from("starknet is good ");

    let back_str = take_and_give_back(origin_str);

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

    let test_str = String::from("BTC to the moon");

    let (test_str, length) = test_return_two_result(test_str);

    println!("test_str= {}, length={} ",test_str,length);

    let len = deliver_reference_test(&test_str);

    println!("The length of '{}' is {}.", test_str, len);

    let mut loot = String::from("loot realms");

    test_change_str_with_reference(&mut loot);

    println!("{}",loot);

    other_mut_reference_test();

    string_slice_test();

    let mut input_str = String::new();

    io::stdin().read_line(&mut input_str ).expect("Failed to read line");

    let first_word = get_first_word(&input_str);

    println!("the  first word is: {}",first_word);

}

fn get_first_word(s: &String) -> &str {

    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate(){

        if item == b' '{

            return &s[0..i];//如果碰到了第一个空格,那么就返回这个字符串的第一个单词

        }

    }

    return &s[..];

}

fn test_change_str_with_reference(s: &mut String){

    s.push_str(" to the moon");

}

fn test_return_two_result(s: String) -> (String, usize){

    let length = s.len();

    return (s, length);

}

fn deliver_reference_test(test_str: &String) -> usize{

    return test_str.len();

}

fn take_ownership(hello_str:String){

    println!("{}",hello_str);

}

fn take_and_give_back(hello_str:String) -> String {

    return hello_str;

}

fn give_ownership_in_fn() -> String{

    return String::from("hello");

}

fn input_number_test(){

    let mut input = String::new();

    println!("Please enter a number.");

    io::stdin().read_line(&mut input).expect("Failed to read line");

    let input: i32 = input.trim().parse().expect("Please type a number!");

    println!("You entered: {}", input);

}

fn input_array_index_test(){

    let mut first_input = String::new();//定义一个变量接收输入值

    println!("Please enter the first number:");//打印提示信息

    io::stdin().read_line(&mut first_input).expect("Failed to read line");//读取输入的值,并且做异常处理

    let first_input:i32 = first_input.trim().parse().expect("Please type a number!");//将输入的值转换成i32类型

    println!("Please enter the second number:");//打印提示信息

    let mut second_input = String::new();//读取第二个值

    io::stdin().read_line(&mut second_input).expect("Failed to read line");//读取输入的值并赋值给second变量,并且做异常处理

    let second_input:i32 = second_input.trim().parse().expect("Please type a number!");//将输入的值转换成i32类型

    let result:i32 = to_add(first_input,second_input);//调用to_add函数,并且将返回值赋值给result变量

    println!("The result is: {}",result);//打印结果

    if result /2 == 0 {

        println!("result is even");

    } else {

        println!("result is odd");

    }

}

fn print_labled_measurement(value:i32, unit_label: char){

    println!("the measurement is {value}, {unit_label} ");

}

fn to_add(x: i32, y:i32) -> i32{

    x+y //不能有分号,因为是一个表达式,不是一个语句,语句是需要有分号,这里加了分号要报错的.

}

fn for_loot_test(){

    let num_array = [10,20,30,40,50];

    for num in num_array {

        println!("the number is: {}",num);

    }

}

fn while_loop_test() {

    let mut number = 0;

    let mut sum = 0;

    while number <100 {

        sum += number;

        number += 1;

    }

    println!("the sum from 0 to {} is: {}",number,sum);

}

fn other_mut_reference_test(){

    let mut test_str = String::from("loot lords cc ");

    let first = &test_str;

    let second = &test_str;

    println!("{} and {}",first,second);

    let r3 = &mut test_str;

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

}

fn for_range_test(start:i32, end :i32) -> i32{

    if start >= end {

        return 0;

    }

    let mut sum = 0;

    for number in start..end {

        sum += number;

    }

    return sum;

}

fn string_test(){

    let mut s = String::from("hello");

    s.push_str(", world!");

    println!("{}",s);

}

fn string_slice_test(){

    let s = String::from ("eth to the moon");

    let slice1 = &s[..4];

    println!("{}",slice1);

}