07_Rust中的数据类型

Rust中的数据类型

Rust中的数据类型主要分为两种：

• 标量数据类型
• 复合数据类型

标量数据类型

在其他语言里，如C语言，则称标量数据类型为基本数据类型，就是包含整型、浮点型、字符类型等。在Rust中的标量数据类型也差不多是这些。

整型

是一个没有小数部分的数字。

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

其中i是integer的意思，u是unsigned integer的意思。

因为学Rust的同学基本都学过C语言了，所以这些非常非常基础的东西就不再累赘了，因为都差不多的，一些差异的内容需要补充的可以到Rust官网中查看。Rust官方文档：数据类型 - Rust 程序设计语言 简体中文版 (kaisery.github.io).

浮点数

对应C语言的float和double类型。

默认是f64即默认是双精度浮点型。

Rust	C
f32	float
f64	double

Rust的符号表可查看Rust官方文档：B - 运算符与符号 - Rust 程序设计语言 简体中文版 (kaisery.github.io).

字符类型

对应C语言的char，在Rust里也是以char为关键字。

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '';
}

Rust的字符默认使用Unicode编码，C语言一般是使用ASCII编码（这个由编辑器决定，有些地方出现乱码是因为编辑器使用的编码和终端显示的编码不对应导致的）。

复合数据类型

复合类型（Compound types）可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple）和数组（array）。

元组

元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小。

从C语言的角度看，元组就是简写的结构体类型。在C++中也有元组类型，在C++中元组是一个模板类。

创建元组的格式：

//let 变量名（元组名）: (类型1,类型2,...,类型n) = (值1,值2,...,值n);
//例如：
let tup: (i32, f64, u8) = (500, 6.4, 1);

元组中的每一个位置都有一个类型，而且这些不同值的类型也不必是相同的。

元组中当然也可以嵌套一个元组类型，例如：

let tup:(i32,(i32,u32,char),usize)=(3,(4,5,'e'),8);

访问元组中的成员

模式匹配来解构元组值:

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

结果：

The value of y is: 6.4

访问运算符 (.) ：

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;		//访问第0个成员即i32

    let six_point_four = x.1;	//访问第1个成员即f64

    let one = x.2;				//访问第2个成员即u8
}

单元元组（空元组）

不带任何值的元组有个特殊的名称，叫做 单元（unit） 元组。这种值以及对应的类型都写作 ()，表示空值或空的返回类型。如果表达式不返回任何其他值，则会隐式返回单元值。

数组

数组这个东西就不用过多介绍了，学C的早就玩惯了。

Rust中的数组：

• 每个元素的类型必须相同。

• 数组长度固定。

Rust中的数据创建和C语言是有一点区别。比较直观一点的是Rust使用中括号，C语言使用大括号。

常规声明：

//let 数组名: [单元类型; 数组长度n] = [值1,值2,...,值n];
let a: [i32; 5] = [1, 2, 3, 4, 5];
//let 数组名 = [值1,值2,...,值n];		编译器会自动推断类型和长度
let a = [1, 2, 3, 4, 5];

填充声明：

//let 数组名 = [填充值; 数组长度n];
let a = [3; 5];
//等效：let a [i32, 5] = [3, 3, 3, 3, 3];

访问数组元素

这一点和C语言是一模一样的，也是从0开始计数。

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

在Rust中也是不能越界访问的：

fn main() {
    let a = [1, 2, 3, 4, 5];
    let v = a[5];  //错误
    let v = a[-1]; //错误
}

程序在索引操作中使用一个无效的值时导致 运行时 错误。程序带着错误信息退出。

当尝试用索引访问一个元素时，Rust 会检查指定的索引是否小于数组的长度。如果索引超出了数组长度，Rust 会 panic，这是 Rust 术语，它用于程序因为错误而退出的情况。这种检查必须在运行时进行，特别是在这种情况下，因为编译器不可能知道用户在以后运行代码时将输入什么值。

这是第一个在实战中遇到的 Rust 安全原则的例子。在很多底层语言中，并没有进行这类检查，这样当提供了一个不正确的索引时，就会访问无效的内存。通过立即退出而不是允许内存访问并继续执行，Rust 让你避开此类错误。