rust 笔记之变量与函数

变量

  • 默认为不可变变量,一旦绑定赋值将不再允许改变。
1
let x=1;//默认推断为i32类型
  • 定义为可变变量后变量可被随意改变。
1
let mut x=1;

常量与变量的区别

  • 常量的一旦定义不可再变。
  • const 声明,不能用 mut修饰。
  • 常量可以在任何作用域中声明。
  • 在编译期确定值,而变量在运行期确定值。
  • 常量使用全大写字母作为名称,下划线_隔开单词。

隐藏(Shadowing)

  • 可通过隐藏变量对一个不可变变量“重新赋值”,实质上是重新定义了一个新的变量。
1
2
3
4
5
6
7
8
9
fn main() {
    let x = 5;

    let x = x + 1;

    let x = x * 2;

    println!("The value of x is: {}", x);//  x 的值最终为12
}

数据类型

标量

整型:

长度 有符号 无符号
8-bit i8 u8
16-bit i16 u16
32-bit i32 u32
64-bit i64 u64
128-bit i128 u128
arch isize usize
  • 每一个有符号的变体可以储存包含从 -(2n - 1)2n - 1 - 1 在内的数字,这里 n 是变体使用的位数。所以 i8 可以储存从 -(27)27 - 1 在内的数字,也就是从 -128127
  • 无符号的变体可以储存从 02n - 1 的数字,所以 u8 可以储存从 028 - 1 的数字,也就是从 0255
  • isize 和 usize 类型依赖运行程序的计算机架构:64 位架构上它们是 64 位的, 32 位架构上它们是 32 位的。
  • 整形字面值:
    数字字面值 例子
    Decimal (十进制) 98_222
    Hex (十六进制) 0xff
    Octal (八进制) 0o77
    Binary (二进制) 0b1111_0000
    Byte (单字节字符)(仅限于u8) b'A'
  • byte 以外的所有数字字面值允许使用类型后缀,例如 57u8,同时也允许使用 _ 做为分隔符以方便读数,例如 1_000
  • debug 构建中 rust 会检查整形溢出并报错。
  • release 构建中不会检查溢出,会进行二进制补码包装。u8 赋值 256 会变成 0,赋值 257 会变成 1,以此类推。标准库 wrapping 类型显示这种行为。

浮点型

  • f32 和 f64 两个浮点数据类型。
  • 默认 f64 类型,因为在现代 cpu 中性能差异不大的前提下 f64 精度更高。
  • 基本运算:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
fn main() {
    // 加法
    let sum = 5 + 10;

    // 减法
    let difference = 95.5 - 4.3;

    // 乘法
    let product = 4 * 30;

    // 除法
    let quotient = 56.7 / 32.2;

    // 取余
    let remainder = 43 % 5;
}

布尔型

  • 用 bool 表示,只有两个可能的值: true false
1
2
3
4
5
fn main() {
    let t = true;

    let f: bool = false; // 显式指定类型注解
}

字符类型

  • 字符串用双引号引起来。
  • 单引号表示 char 类型,大小为 4 个字节,代表一个 Unicode 标量值但是又有所区别,是 rust 特有的原生字符类型。

复合类型

  • 多个值组合的类型。包含元组(tuple)和数组(array) 两个原生复合类型。

元组

  • 元素可包含不同类型,声明后长度不可变。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
fn main() {
    // 声明并赋值
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    // 赋值
    let tup = (500, 6.4, 1);
    // 取值,使用模式匹配(pattern matching)来解构(destructure)元组值
    let (x, y, z) = tup;
    println!("The value of y is: {}", y);
    // 还可以使用 . 运算符取值
    let five_hundred = x.0;
    let six_point_four = x.1;
    let one = x.2;
}

数组类型

  • 区别于元组,数组的元素类型必须是相同的。长度不可变,标准库中提供 vector 类型可实现可变长度数组。
  • 声明方式:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
fn main() {
    let a = [1, 2, 3, 4, 5];
    // 自动推断长度和类型
    let months = ["January", "February", "March", "April", "May", "June", "July","August", "September", "October", "November", "December"];
    // 指定类型和长度
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    // 长度为 5 每个元素的值都是 3,等同于 let a = [3, 3, 3, 3, 3];
    let a = [3; 5];
    // 读取元素  
    let first = a[0];
    let second = a[1];
}
  • 下标溢出时编译期不会出错但是会产生 runtime 错误。

函数

  • 基本函数结构
1
fu another_function(x: i32){}
  • 名称都是小写字母构成,用下划线 _ 隔开单词。
  • 函数体由一系列的语句和一个可选的结尾表达式构成。
  • 语句指没有返回值的指令,如let y = 6;,表达式执行一些计算操作并且有返回值。
  • 不能将语句赋值给变量。
  • 语句可以包含表达式,一般的语句以 ; 结束,表达式后面不跟分号。
  • rust 是一个基于表达式的语言。

具有返回值的函数

1
2
3
4
5
6
7
8
9
// 该函数在 rust 中有效,返回 5
// 但是函数内容必须是一个表达式,不能在末尾添加分号
fn five() -> i32 {
    5
}
// 以元组返回
fn five() -> (i32,u8) {
    (1,2)
}
  • 可以用 return 提前返回值。
updatedupdated2021-05-262021-05-26
加载评论