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 程式設計語言（第一版） 簡體中文版