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的数组下标也是从

开始。

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 程序设计语言（第一版） 简体中文版