Rust简易入门（三）

Rust的流程控制主要包括条件语句（if、else、else if）、循环语句（for、while）和跳转语句（break、continue、return）。这些语句使程序员能够根据特定的条件或循环执行代码块，从而实现各种复杂的逻辑控制。例如，if语句允许程序员根据条件执行代码，而for和while循环则用于重复执行代码块，直到满足特定的条件。

if流程控制与match模式匹配

fn main() {
    let age = 50;
    if age < 50 {
        println!("你还年轻");
    } else {
        println!("你老了");
    }
    
    let num = 90;
    match num {
        80..=89 => println!("80 .. =89"),
        90 => println!("90"),
        95|100 => println!("95 | 100"),
        _ => println!("some else")
    }
    
}

循环与break continue以及与迭代的区别

fn main(){
    // loop {
    //     println!("Ctrl+C");
    //     std::thread::sleep(std::time::Duration::from_secs(1));
    // }
    
    'outer: loop {
        println!("outer");
        loop {
            println!("inner");
            break 'outer;
        }
    }
    
    // 循环的写法
    let numbers = [1, 2, 3, 4, 5];
    let mut for_numbers = Vec::new();
    for &number in numbers.iter() {
        let item = number * number;
        for_numbers.push(item);
    }
    println!("for : {:?}", for_numbers);
    
    // 迭代器的写法
    let numbers = [1,2,3,4,5].to_vec();
    let iter_number: Vec<_> = numbers.iter().map(|&x| x*x).collect();
    println!("for : {:?}", iter_number);
}

函数基础与Copy值传递

函数的定义：在Rust中函数的关键字为fn

参数与返回值：函数可以接受零个或者多个参数，每个参数都需要指定类型，函数可以有返回值，使用 →指定返回值类型，若无返回值可以使用 →()或者省略

如果数据类型实现Copy特质，则在函数传参时会实现Copy by value

Struct、美剧、集合等并没有实现Copy特质，会实现move操作失去所有权

fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn change_i32(mut x: i32) {
    x += 4;
    println!("{x}");
}

fn modify_i32(x: &mut i32){
    *x += 5;
}


#[derive(Copy, Clone)]
struct Point{
    x: i32,
    y: i32,
}

fn print_point(point: Point){
    println!("point x {}", point.x);
}

fn main() {
    let a = 1;
    let b = 2;
    let c = add(a, b);
    println!("{c}");
    
    let mut x = 1;
    change_i32(x);
    println!("x {x}");
    modify_i32(&mut x);
    println!("x {x}");
    
    let s = Point{x: 1, y: 2};
    print_point(s); // move
    println!("point y {}", s.y);
}

函数值参数传递、不可变借用参数传递、可变借用参数传递

fn move_func(p1: i32, p2: String) {
    println!("p1 is {}", p1);
    println!("p2 is {}", p2);
}

fn print_value(value: &i32) {
    println!("{}", value);
}

fn string_func_borrow(s: &String) {
    println!("{}", (*s).to_uppercase());
}

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn modify_point(point: &mut Point) {
    (*point).x += 2;
    point.y += 2;
}

fn main() {
    let n = 12;
    let s = String::from("00");
    move_func(n, s);
    println!("{}", n);
    
    let s = String::from("oo");
    print_value(&n);
    print_value(&n);
    string_func_borrow(&s);
    println!("s is {}", s);
    
    let mut p = Point{x: 0, y: 0};
    println!("{:?}", p);
    modify_point(&mut p);
    println!("{:?}", p);
}

函数返回值与所有权机制

函数的返回值分为：返回值类型、返回引用类型

1. 返回值类型 Copy与 Non-Copy

都可以返回，Non-Copy分配在堆上

返回Copy类型的值通常具有更好的性能，Copy类型的值是通过复制来进行返回，不涉及堆上内存的分配和释放，通常是在栈上分配

2. 返回引用

在只有传入一个引用参数且只有一个返回引用时，生命周期不需要声明

其他状况需要标注生命周期

慎用 'static

fn func_copy_back() -> i32 {
    let n = 53;
    n
}

fn func_non_copy_back() -> String { // 栈上分配
    let s = String::from("hello");
    s
}

fn get_mess(mark: i32) -> &'static str {
    if mark == 0 {
        "

标签：入门,numbers,i32,简易,let,fn,println,Rust,函数	

From： https://www.cnblogs.com/moguw/p/18105699