2.原生类型

原生类型的种类

原生类型文档

---

标量类型（scalar type）	复合类型（compound type）
有符号整数	数组
无符号整数	元组
浮点数
char（字符）
bool（布尔型）
单元类型（unit type）

---

标量类型

• 有符号整数（signed integers）：i8、i16、i32、i64、i128 和 isize（指针宽度）
• 无符号整数（unsigned integers）： u8、u16、u32、u64、u128 和 usize（指针宽度）
• 浮点数（floating point）： f32、f64
• char（字符）：单个 Unicode 字符，如 ‘a’，‘α’ 和 ‘∞’（每个都是 4 字节）
• bool（布尔型）：只能是 true 或 false
• 单元类型（unit type）：()。其唯一可能的值就是 () 这个空元组

---

复合类型

• 数组（array）：如 [1, 2, 3]
• 元组（tuple）：如 (1, true)

---

字面量和运算符

• 对于位运算来说就是相当于布尔运算。
• 注意Rust之中的短路求值
• rust中的运算符优先级和结合性和C语言相同。

---

元组

• 输出元组的时候需要添加#[derive(debug)],或者自定义fmt::display，这在第一章有过解释。
• 元组和其他不同的地方是可以由多个不同类型的值所组成。
• 可以使用let将元组中的成员帮定在一些变量之中。

    // 可以使用 `let` 把一个元组的成员绑定到一些变量
    let (f1, f2,f3,f4) = Matrix;

• 元组可以作为函数的返回值，这就是为什么在返回值中看到:

// 元组可以充当函数的参数和返回值
fn reverse(pair: (i32, bool)) -> (bool, i32) {
    // 可以使用 `let` 把一个元组的成员绑定到一些变量
    let (integer, boolean) = pair;

    (boolean, integer)
}

• 元组太长的时候是不可以打印的。
• 创建单元素元组需要添加额外的逗号，是为了和字面量进行区分。
• 元组可以解构：

    // 元组可以被解构（deconstruct），从而将值绑定给变量
    let tuple = (1, "hello", 4.5, true);

    let (a, b, c, d) = tuple;
    println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);

• 动手问题：
• • 动手问题1

use std::fmt;

struct Matrix(f32, f32, f32, f32);

impl fmt::Display for Matrix{
    fn fmt(&self,f:&mut fmt::Formatter) -> fmt::Result{
        write!(f,"({} {}) 
({} {})",self.0,self.1,self.2,self.3)
    }
}

fn main()
{
    let matrix = Matrix(1.1,1.2,2.1,2.2);
    
    println!("{}",matrix);
}

• • 动手问题2

use std::fmt;

struct Matrix(f32, f32, f32, f32);

impl fmt::Display for Matrix{
    fn fmt(&self,f:&mut fmt::Formatter) -> fmt::Result{
        write!(f,"({} {}) 
({} {})",self.0,self.1,self.2,self.3)
    }
}

impl Matrix {
    fn transpose(&self) -> Matrix{
        Matrix(self.0,self.2,self.1,self.3)
    }
}

fn main()
{
    let matrix = Matrix(1.1,1.2,2.1,2.2);
    
println!("Matrix:\n{}", matrix);
println!("Transpose:\n{}", matrix.transpose());
}

• 这里要说明的是：直接使用函数进行元组中的切换比较困难，所以使用方法进行设置就好。因为如果直接使用函数，就要给这个函数设置输出格式，会比较麻烦。

---

数组和切片

• 数组的标记类型为[元素类型 T;元素长度length]，而切片的对象是为[指针，切片长度]，切片的标记类型为[&T]。
• 切片在编译过程中大小不固定，而数组在编译过程中会确定。
• 切片长度和usize相同，由处理器架构决定。因为切片是指针，切片长度，所以切片一般是引用。

use std::mem;

// 此函数借用一个 slice
fn analyze_slice(slice: &[i32]) {
    println!("first element of the slice: {}", slice[0]);
    println!("the slice has {} elements", slice.len());
}

fn main() {
    // 定长数组（类型标记是多余的）
    let xs: [i32; 5] = [1, 2, 3, 4, 5];

    // 所有元素可以初始化成相同的值
    let ys: [i32; 500] = [0; 500];

    // 下标从 0 开始
    println!("first element of the array: {}", xs[0]);
    println!("second element of the array: {}", xs[1]);

    // `len` 返回数组的大小
    println!("array size: {}", xs.len());

    // 数组是在栈中分配的
    println!("array occupies {} bytes", mem::size_of_val(&xs));

    // 数组可以自动被借用成为 slice
    println!("borrow the whole array as a slice");
    analyze_slice(&xs);

    // slice 可以指向数组的一部分
    println!("borrow a section of the array as a slice");
    analyze_slice(&ys[1 .. 4]);

    // 越界的下标会引发致命错误（panic）
    println!("{}", xs[5]);
}