Rust 学习笔记 变量 数据类型

变量

• 声明一个不可变的变量，x就指向当前12存储在栈上面的内存地址，let是对一个变量的绑定，Rust可推断类型,变量y的类型可忽略不写，默认就是i32类型

let x = 12;
println!("x = {}", x);
let y: i32 = 12;
println!("y = {}", y);

• 不可变变量禁止重新赋值

let x = 12;
x = 13;//Error

• 需要可变变量,需在let后面跟上mut关键字表示可变

let mut x = 12;
println!("x = {}", x);
x = 13;
println!("x = {}", x);

println!是一个宏，{}表示占位符

• 隐藏变量，Rust允许我们使用相同的变量名来覆盖前面相同的变量名，并且我们还可以改变变量的数据类型

let x: i32 = 11;
println!("x1 = {}", x);
let x: i32 = x + 1;
println!("x2 = {}", x);
let x: String = x.to_string();
println!("x3 = {}", x);

数据类型

Rust是静态类型语言，所以在编译期必须知道所有的变量类型，Rust编译器一般情况下都可以帮我们推断出所需要的类型，可以忽略不写

标量类型

标量类型
整型
浮点型
布尔类型
字符类型

整型

• 有符号就代表可能存在负数，无符号则代表大于等于0

• 值的范围-(2^n-1)到2^n-1-1，n就是声明的长度，例如：i8的范围是-(2^8-1)到2^8-1-1，u8的范围是0到2^8-1-1

• isize 和 usize 类型依赖运行程序的计算机架构：64 位架构上它们是 64 位的，32 位架构上它们是 32 位的。

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

• 整型溢出

在debug环境编译cargo run，如果u8的值超出了它自身的范围，编译器会panic报错attempt to add with overflow，而在release环境编译cargo run --release，则会进行补码，256的值会输出为0，257的值会输出为1，以此类型

let x: u8 = 255;
println!("x1 = {}", x);
let x: u8 = x + 1;
println!("x2 = {}", x);

浮点型

浮点型	精度
f32	单精度浮点数
f64	双精度浮点数

• 小数默认类型是f64

数值运算

• 同其他语言(注意：是同类型计算)

let x = 1 + 1;
println!("x = {}", x);
let x = 1 * 1;
println!("x = {}", x);
let x = 1 - 1;
println!("x = {}", x);
let x = 5 / 3;
println!("x = {}", x);
let x: f64 = 5.0 / 3.0;
println!("x = {}", x);
let x = 5 % 2;
println!("x = {}", x);

布尔型

• 同其他语言

let x = true;
println!("x = {}", x);
let y: bool = false;
println!("y = {}", y);

字符类型

• 单引号表示单字符char(但是有4个字节，可以表示其他国家语言文字中的变音符号、或者特殊的emoji)，双引号则代表字符串字面量&str

let x = 'x';
let y = "y";

复合类型

• 可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple）和数组（array）,同其他语言类型，例如python

元祖

• 元祖()里面可以包含多种类型组合，可以使用解构或者索引来读取对应的值

let tuple: (&str, u8, bool, char) = ("哈哈", 1, true, 'A');
let (a, b, c, d) = tuple;
println!("a = {}", a);
println!("b = {}", b);
println!("c = {}", tuple.0);
println!("d = {}", tuple.1);

数组

• 数组[]里面只能包含相同类型的值，数组的值是固定的、已知的，如果需要可变有其他的类型表示(vector)
• [i32; 6]左边表示类型，右边表示数组大小
• array[0]可以通过读取下标来取出对应的值

let array: [i32; 6] = [1, 2, 3, 4, 5, 6];
let array = [1, 2, 3, 4, 5, 6];
println!("array = {:?}", array);
let first = array[0];
println!("first = {:?}", first);
let second = array[1];
println!("second = {:?}", second);

• 另一种数组表达方式：[1; 10]表示有10个初始值为1的数组

let array = [1; 10];
println!("array = {:?}", array);

对于非结构体也可以直接使用 {:?} 进行输出，但是对于结构体，需要派生Debug特征后，才能进行输出。println!还有很多种表达方式