数据类型

分类

标量（scalar）和复合（compound）// 原生类型

Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。都存储在栈中，并且当离开作用域时被移出

标量

  • 整型(默认i32)

    长度有符号无符号
    8-biti8u8
    16-biti16u16
    32-biti32u32
    64-biti64u64
    128-biti128u128
    archisize(指针宽度)usize(指针宽度)

  • 浮点(默认为f64): f32, f64

  • char: 单个Unicode字符， ‘a' (4字节)

  • bool: true, false

  • 单元类型(unit type): 其唯一可能的值就是 () 这个空元组, 尽管单元类型的值是个元组，它却并不被认为是复合类型，因为并不包含多个值。

数字还可以通过后缀 （suffix）或默认方式来声明类型： 8i32, 10u32

复合

  • 数组(array)：如 [1, 2, 3]，
    • 数组中的每个元素的类型必须相同，长度固定,内存中是连续存储的：一旦声明，其长度不会增大或缩小。并且在编译的时候是确定了的。
      • 内存中是连续存储的
  • 元组(tuple)：如 (1, true)，元组长度固定：一旦声明，其长度不会增大或缩小。

字面量和运算符

字面量

  • 整数 1、浮点数 1.2、字符 'a'、字符串 "abc"、布尔值 true 和单元类型 (); 前缀 0x、0o、0b，数字可以用十六进制、八进制或二进制记法表示.

  • 可读性，可以在数值字面量中插入下划线，比如：1_000 等同于 1000， 0.000_001 等同于 0.000001。

  • 字符串字面值来说，我们在编译时就知道其内容，所以文本被直接硬编码进最终的可执行文件中，它是一个指向二进制程序特定位置的 slice。这也就是为什么字符串字面值是不可变的

    运算符

    fn main() {
    // 整数相加
    println!("1 + 2 = {}", 1u32 + 2);

    // 整数相减
    println!("1 - 2 = {}", 1i32 - 2);
    // 试一试 ^ 尝试将 `1i32` 改为 `1u32`，体会为什么类型声明这么重要

    // 短路求值的布尔逻辑
    println!("true AND false is {}", true && false);
    println!("true OR false is {}", true || false);
    println!("NOT true is {}", !true);

    // 位运算
    println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101);
    println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
    println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101);
    println!("1 << 5 is {}", 1u32 << 5);
    println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);

    // 使用下划线改善数字的可读性！
    println!("One million is written as {}", 1_000_000u32);
}

元组

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

    (boolean, integer)
}

// 在 “动手试一试” 的练习中要用到下面这个结构体。
#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main() {
    // 包含各种不同类型的元组
    let long_tuple = (1u8, 2u16, 3u32, 4u64,
                      -1i8, -2i16, -3i32, -4i64,
                      0.1f32, 0.2f64,
                      'a', true);

    // 通过元组的下标来访问具体的值
    println!("long tuple first value: {}", long_tuple.0);
    println!("long tuple second value: {}", long_tuple.1);

    // 元组也可以充当元组的元素
    let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);

    // 元组可以打印
    println!("tuple of tuples: {:?}", tuple_of_tuples);

    // 但很长的元组无法打印
    // let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
    // println!("too long tuple: {:?}", too_long_tuple);
    // 试一试 ^ 取消上面两行的注释，阅读编译器给出的错误信息。

    let pair = (1, true);
    println!("pair is {:?}", pair);

    println!("the reversed pair is {:?}", reverse(pair));

    // 创建单元素元组需要一个额外的逗号，这是为了和被括号包含的字面量作区分。
    println!("one element tuple: {:?}", (5u32,));
    println!("just an integer: {:?}", (5u32));

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

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

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

}

数组和切片

切片(slice)

  • 大小在编译时是不确定的
  • 切片是一个双字 对象（two-word object），第一个字是一个指向数据的指针，第二个字是切片的长度.这 个 “字” 的宽度和 usize 相同，由处理器架构决定，比如在 x86-64 平台上就是 64 位。 slice 可以用来借用数组的一部分
  • slice 的类型标记为 &[T]
  • 没有所有权的数据类型, slice允许你引用集合中一段连续的元素序列，而不用引用整个集合.