【Rust】类型，函数，控制，所有权

【Rust】类型，函数，控制，所有权

整类型

长度     有符号   无符号
8-bit    i8      u8
16-bit   i16     u16
32-bit   i32     u32
64-bit   i64     u64
128-bit  i128    u128
arch     isize   usize

let vi8 : i8 = 1;
let vu8 : u8 = 1;
let vi16 : i16 = 1;
let vu16 : u16 = 1;
let vi32 : i32 = 1;
let vu32 : u32 = 1;
let vi64 : i64 = 1;
let vu64 : u64 = 1;
let vi128 : i128 = 1;
let vu128 : u128 = 1;
let vi : isize = 1;
let vu : usize = 1;

浮点类型

长度      符号
32-bit    f32
64-bit    f64

let a : f32 = -1.1;
let b : f32 = 1.1;
let c : f64 = -2.2;
let d : f64 = 2.2;

布尔类型

bool true false

let flag = true;

字符类型

字符四个字节 unicode

let a = 'a';

元组类型

元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小。
我们使用包含在圆括号中的逗号分隔的值列表来创建一个元组。元组中的每一个位置都有一个类型，而且这些不同值的类型也不必是相同的

let tup: (i32, f64, u8) = (500, 6.4, 1);
let (a,b,c) = tup;// 解构值 a=500,b=6.4,c=1
let x = tup.0;// 索引值 x=500
let y = tup.1;
let x = tup.2;

数组类型

长度是固定的，分配在栈上

let a = [1,2,3,4,5];// 没有指定类型和长度，由初始值决定
let b: [u32;5] = [6,7,8,9,0];// 指定类型和长度
let c = ['c';3];// 设置相同的值，相当于['c','c','c']
let d = b[0];//获取数组值

函数

// 没有返回值
fn show(v: u32) {
    println!("{}",v);
}
// retur 返回 u32
fn sum1(a: u32, b: u32) -> u32 {
    return a + b;
}
// 最末尾表达式返回，不能加分号，因为加了分号会使表达式变为语句而报错
fn sum2(a: u32, b: u32) -> u32 {
    a + b
}

注释

//

控制

if

let num: u32 = 10;
// 没有括号
if 5 > num && num > 0 {
} else if 10 > num && num > 5 {
} else if num % 4 == 0 {
} else {
}

loop

let mut num: u32 = 0;
// 使用break终止循环，使用continue继续循环
loop {
    num += 1;
    if num % 2 == 0 {
        continue;
    }
    if num > 10 {
        break;
    }
    println!("{}",num);
}
// 使用break终止循环并返回值
let result = loop {
    if num > 10 {
        break 999; // 返回值
    }
};// 分号不能少，这是语句
println!("{}",result);

while

let mut sum: u32 = 0;
let mut index: u32 = 1;
while index <= 100 {
    sum += index;
    index += 1;
}
println!("{}",sum);

for

let a = [10,20,30,40,50];
for item in a.iter() {
    println!("{}",item);
}
for item in 0..4 {
    println!("{}",item);// 结果0,1,2,3
}
for item in (0..4).rev() {
    println!("{}",item);// 结果3,2,1,0
}

所有权

所有权的规则
Rust 中的每一个值都有一个被称为其 所有者（owner）的变量。
值在任一时刻有且只有一个所有者。
当所有者（变量）离开作用域，这个值将被丢弃。

Rust 采取了一个不同的策略：内存在拥有它的变量离开作用域后就被自动释放

变量与数据交互

方式（一）：移动

let s1 = String::from("hello");
let s2 = s1;
// s1 不能再用

方式（二）：克隆

let s1 = String::from("hello");
let s2 = s1.clone();
// s1,s2都可用

栈上的数据：复制
实现了Copy trait 整数、布尔、浮点、字符、元组

向函数传递值可能会移动或复制，移动时所有权会转移，复制不会转移
返回值也可以转移所有权

let mut s1 = String::from("hello");
s1 = take(s1);// 转移所有权到函数
println!("{}",s1);

fn take(s: String) -> String {
    s// 返回所有权
}