Rust原生类型

一、原生类型
Rust 提供了多种原生类型，主要包括：标量类型、复合类型。
1.1 标量类型
包含以下几种：

1. 有符号整数：i8、i16、i32、i64、i128 和 isize。
2. 无符号整数： u8、u16、u32、u64、u128 和 usize。
3. 浮点数： f32、f64。
4. char：单个 Unicode 字符。
5. bool：true 或 false。
6. 单元类型：()。其唯一可能的值就是 () 这个空元组。

1.2 复合类型
包含以下几种：

1. 数组：如[1, 2, 3]。
2. 元组：如(1, ‘a’,true)。

1.3变量定义
定义变量时，可以显示指定变量的类型，rust还可以根据上下文来推断类型。数字还可以通过后缀来声明变量的类型。当未指定变量类型，而且无法根据上下文推断时，按默认方式声明类型，其中整型默认为 i32 类型，浮点型默认为 f64类型。
变量绑定默认是不可变的，如果需要可变绑定，则需要加上mut修饰符。

以下是变量定义样例：

fn main() {
    //显示指定变量的类型
    let logical: bool = true;

    //后缀声明类型
    let an_integer   = 5i32;

    //默认方式声明类型
    let default_float   = 3.0; //浮点型默认为f64
    let default_integer = 7;   //整型默认为i32

    //根据上下文自动推断类型
    let mut inferred_type = 12; //根据下一行的赋值推断为i64类型
    inferred_type = 4294967296i64;

    //可变变量，其值可以改变。
    let mut mutable = 12; 
    mutable = 21;
}

二、字面量和运算符
2.1字面量
字面量是用于表示常量的一种方法。如：整数、浮点数以及字符串常量等。
数字可以通过加前缀 0x、0o、0b来分别表示十六进制、八进制或二进制。也可以使用数字加类型后缀的方式来声明字面量的类型。为了改善易读性，还可以在数值字面量中插入下划线，比如：1_000 等同于1000，0.000_001等同于0.000001。

以下是样例：

fn main() {
    //字面量通过后缀表示类型
    let a = 7u8;
    let b = 5.4f64;
    let c = 32i32;
    ​
    //字面量通过前缀表示进制
    let d = 0b1; //二进制
    let e = 0o7; //八进制
    let f = 0xa; //十六进制
    ​
    //字面量通过 “_” 来分割数据，便于可读性
    let g = 10_000;
    let h = 200_000.000_1;
}

2.2 运算符
rust运算符的优先级和类C语言类似，下面将操作符和表达式按优先级由高到低的顺序列出来

以下是简单的样例：

fn main() {
    //二元计算操作
    println!("1 + 2 = {}", 1u32 + 2);
    println!("1 - 2 = {}", 1i32 - 2);

    //逻辑操作
    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);
}

三、元组
元组是一个可以包含各种类型值的组合，是把几个类型组合到一起的最简单的方式。元组使用括号 () 来构造。如果元组中只包含一个元素，应该在后面添加一个逗号，以区分号表达式和元组。

以下是简单的样例：

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);
    println!("long_tuple: {:?}", long_tuple);

    //元组也可以充当元组的元素
    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);

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

四、数组和切片
数组是一个容器，它在一块连续空间内存中，存储了一系列的同类型的数据。数组中元素的占用空间大小必须是编译期确定的。

对数组取借用borrow操作，可以生成一个“数组切片”（Slice）。组切片对数组没有“所有权”，我们可以把数组切片看作专门用于指向组的指针，是对数组的另外一个“视图”。比如，我们有一个数组[T；n]，它的借用指针的类型就是&[T；n]。

以下是一个简单的样例：

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]);
}