rust 语法和语义 04 原生类型

rust 语法和语义 04 原生类型

原生类型 primitive types

本章讲述 rust 内建的数据类型。

概述

类型名	类型	说明
bool	bool	true or false
char	char	'c' 32-bits unicode
integer	i/u + 8/16/32/64
size	isize or usize	依赖底层机器指针大小
float	f32 or f64	IEEE-754
array	[T; N]	[Type; Number]
slice	&[T]	&[Type]
str
tuple	(Tn,)
function	fn(i32) -> i32	函数指针

布尔型 booleans

let x       = true;
let x: bool = false;

---

字符型 char

代表一个 unicode 字符，所以其长度为 4 Bytes, 32-bits 。

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

---

数字类型 numeric types

分类

• 有符号 和 无符号
• 定长 和 变长
• 浮点 和 整型。

默认类型：

let x = 42;     // integer default is i32
let y = 1.0;    // float   default is f64

整型 integer

let x: i32 = 1;
let y: u8  = 2;

• 整型有符号区别：i代表有符号，u代表无符号。
• 整型支持的位长：8 / 16 / 32 / 64 。

可变大小整型 variable size

依赖 底层机器指针 / 硬件架构 大小的类型。有符号位区分。

let x: isize = 1;
let y: usize = 2;

浮点型 floating-point

支持 IEEE-754 的 单精度f32 和 双精度f64 浮点数。

let x: f32 = 1.0;
let y: f64 = 2.0;

---

数组 arrays

c中所说的 数组array，其他现代语言所描述的 列表list。一个定长的，相同元素类型的列表。

let a = [1, 2, 3];         // a: [i32; 3]
let mut b = [1, 2, 3, 4];  // b: [i32, 4]

数组类型

数组的类型:[T: N]。T = Type, N = Number。

快速初始化

将数组中每个元素都初始化相同值的简写方法。

let a : [i32, 20] = [0; 20];

数组长度 len()

获取数组长度的方法：.len() 。

let a = [1,2,3];
println!("array len = {}", a.len());

mint：类似于c中使用了 sizeof(array) / sizeof(array_type) 。

下标访问

let a = [1,2,3];
println!("array 1st element = {}", a[0]);

rust的数组下标也是从 0 开始。

rust中，数组访问在 运行时 会进行 边界检测 方式。

---

切片 slices

一个 切片slice 是一个数组的 引用 。因为是指针引用而不用进行数据copy。在底层，切片代表：

1. 一个指向数据开始的指针
2. 和一个长度

类型

切片的类型：&[T]。&代表一个引用，[]包含切片的长度。

let a : [u32; 5] = [1, 2, 3, 4, 5];
let complete : &[u32] = &a[..];
let middle   : &[u32] = &a[1..4]; // 1, 2, 3

切片的长度 ∈ [下标, 上标)

mint: 类似于c中 struct {type *pStart; u32 len;};

---

字符串 str

字符串类型是 不定长 类型。在引用后将变得很好用 &str 。

---

元组 tuple

元组是固定大小的有序列表。

let x : (i32, &str) = (1, "hello");

异质 heterogeneous

元组是异质的。元组的每个元素可以不是同一个类型，如，

• (i32, &str) 。
• 其长度为 2 (2个元素)。

mint：但tuple没有 .len() 的方法。。。

赋值

如果两个元组包含 相同的类型 和 相同的数量 ，两个元组可以赋值。

let mut x = (1, 2);
let y = (2, 3);
x = y;

还记得 变量绑定 中的 模式 吗？

let (x, y, z) = (1, 2, 3);

let会 解构destructures 元组，并分成多个 绑定bindings 。

歧义

括号中只有单个元素时，添加逗号表明其实元组（和python等一样）。

• 元组 (1,);
• 数字 (1);

元组索引 tuple indexing

不同于数组索引使用 [] ，元组索引使用 . 。

let xyz = (1,2,3);
let x = xyz.0;
let y = xyz.1;
let z = xyz.2;

---

函数 function

fn foo(x : i32) -> i32 = { x }
let x : fn(i32) -> i32 = foo;

x是个指针，指向一个函数。

---

参考

• The Rust Programming Language
• Rust 程序设计语言（第一版） 简体中文版