Rust基础——开始

开始

Rust是一种系统级编程语言，旨在提供内存安全、并发性和高性能。它通过严格的所有权模型来避免常见的内存错误，如空指针解引用和数据竞争，使得开发者能够编写安全可靠的代码

注释

• //：单行注释
• /**/：块注释

变量

变量使用let关键字声明，分为可变变量和不可变变量，常量使用const关键字声明

声明变量时，rust支持自动推断变量类型

let a = 10;  // 可变变量
let mut b = 20;  // 不可变变量
const C: i32 = 30;  // 常量

变量覆盖

在同一作用域内，使用let声明一个同名变量时，会覆盖之前的变量

在再次声明同名变量时，可以使用已存在的同名变量进行赋值

let a: i32 = 10;
let a: String = a.to_string();
println!("{a}");

数据类型

rust的数据类型分为两类，分别是标量类型（基本数据类型）和复合类型（集合类型）

标量类型

rust的标量类型包含整数、浮点数、字符和布尔值

整数

分为有符号数和无符号数，对于不同的长度有指定的类型

整数的默认类型为i32

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

浮点数

浮点数有f32和f64，浮点数默认类型为f64，所有浮点数都是有符号数

进制表示

数字字面值	例子
Decimal (十进制)	98_222
Hex (十六进制)	0xff
Octal (八进制)	0o77
Binary (二进制)	0b1111_0000
Byte (单字节字符)(仅限于u8)	b'A'

布尔值

布尔值有true和false

字符

使用''声明字符字面量，rust的字符大小为4个字节，支持Unicode字符

复合类型

rust中原生包含元组（tuple）和数组（array）两种复合类型

• 元组：长度固定，元素固定，可以包含多种不同类型的值

  // 元组的类型为(type1, type2, type3)
  let x: (i32, f64, u8) = (500, 6.4, 1);
      
  // 使用.访问元素
  let five_hundred = x.0;
  let six_point_four = x.1;
  let one = x.2;
      
  // 元组支持解构赋值
  let (y1, y2, y3) = x;
  

  不含元素的元组的类型为()，表示空值和空返回值，若表达式不返回任何值，默认返回()

• 数组：长度固定，元素不固定，元素的类型必须相同

  // 数组的类型为[type; length]
  let a: [i32; 5] = [1, 2, 3, 4, 5];
      
  // 使用[]访问元素
  let first = a[0];
  let second = a[1];
  

  创建相同值的数组

  let a: [i32; 5] = [3; 5]  // 等价于let a = [3, 3, 3, 3, 3]
  

函数

使用fn关键字声明一个函数，必须声明参数列表类型和返回值类型

fn add(a: i32, b: i32) -> i32 {
    return a + b;
}

语句和表达式

• 语句：执行一些操作并不返回值，需要以;结尾

  let a = (let b = 10);  // 语法错误，let是一个语句
  

• 表达式：执行操作并返回值

  // 一个代码块是一个表达式，可以赋值给a
  let a = {
      let b = 10;
      b + 1
  }
  

尾表达式

一个代码块的最后一行可以使用一个表达式作为返回值，在函数中可以省略return，尾表达式不以;结尾

let a = {
    let b = 10;
    b + 1  // 尾表达式的结果作为代码块的返回值
}

fn add(a: i32, b: i32) -> i32 {
    a + b  // 尾表达式作为函数的返回值
}

控制流

rust支持if条件判断以及loop、while、for三种循环

if条件判断

if后的条件不带括号，条件必须是bool值，整数不会进行隐式转换

if condition {
    statements;
} else if condition1 {
    statements;
} else {
    statements;
}

if表达式

if可以作为一个表达式赋值给变量，必须包含else分支，每个分支的表达式结果必须是相同类型

let b = if a > 10 { 3 } else if a < 0 { 3 } else { 2 };

loop循环

loop循环是一个无限循环，等价于while (1)，可使用break和continue来控制循环

loop {
    println!("again!");
    if a == 10 {
        break;
    }
};

loop表达式

loop块可作为一个表达式，通过break来返回值

let mut counter = 0;
let result = loop {
    counter += 1;
    if counter == 10 {
        break counter * 2;
    }
};  // 作为表达式时，必须以;结尾

循环标签

在嵌套循环时，break和continue默认控制最内层的循环，循环标签可用于控制外层循环

fn main() {
    let mut count = 0;
    // 循环标签以'开头，:结尾，放在循环块之前
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;  // 该break语句会跳出最内层循环
            }
            if count == 2 {
                break 'counting_up;  // 该break语句会跳出指定标签的循环
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

while循环

与其他语言类似

while condition {
    statements;
}

for循环

rust使用for-in循环

let a = [10, 20, 30, 40, 50];
for element in a {
    println!("the value is: {element}");
}

当需要数字序列时，可使用Range类型，使用start..end创建一个Range字面量，范围为左闭右开

for number in 1..4 {
    println!("{number}");
}