Rust入门之数据类型（标量类型和复合类型）

标量类型

一个标量类型代表一个单个的值

Rust有四种标量类型（整数类型，浮点类型，布尔类型，字符类型）

整数类型

i8：有符号整数，占8个bit位，1个字节，范围在-2⁷ - 2⁷ -1

u8：无符号整数,占8个bit位，1个字节，范围在0～2⁸ -1

i16：有符号整数，占16个bit位，2个字节，范围在-2¹⁵- 2¹⁵-1 

u16：无符号整数,占16个bit位，2个字节，范围在0～2¹⁶-1

i32：有符号整数，占32个bit位，4个字节，范围在-2³¹～2³¹-1

u32 : 无符号整数，占32个bit位，4个字节，范围在0～2³²-1

i64：有符号整数，占64个bit位，8个字节，范围在-2⁶³～2⁶³-1

u64: 无符号整数，占64个bit位，8个字节，范围在0～2⁶⁴-1 

i128：有符号整数，占128个bit位，16个字节，范围在-2¹²⁷- 2¹²⁷-1

u128：无符号整数，占128个bit位，16个字节，范围在0～2¹²⁸-1

isize：有符号整数，机器是32位，则范围在-2³¹～2³¹-1，反之则范围在-2⁶³- 2⁶³-1

usize：无符号整数，机器是32位，则范围在 0 ～ 2³²-1，反之则范围在0 ～ 2⁶⁴-1

例子：

let  x:i8 = -128;
let  x:u8 = 255;
let  x:i16 = -32768;
let  x:u16 = 65535;
let  x:i32 = -2147483648;
let  x:u32 = 4294967295;
let  x:i64 = -9223372036854775808;
let  x:u64 = 18446744073709551615;
let  x:i128 = -170141183460469231731687303715884105728;
let  x:u128 = 340282366920938463463374607431768211455;

浮点类型

f32：单精度

f64：双精度

例子：

let x:f64 = 9.9;
let y:f32 = 8.8;

布尔类型

true：为真

false：为假

例子：

let t:bool = true;
let f:bool = false;

字符类型

char：使用单引号，占4个字节

例子：

let z:char = 'x';

复合类型

元组（Tuple）

多个值放在一个类型里面，在小括号中用逗号分开，每个值的类型不必相同，长度不可变

例子：

let tuple = (1,-1,'c',true,9.9);

我们可以通过模式匹配来获取tuple的值

例子：

fn main() {
    let tuple = (1,-1,'c',true,9.9);
    let (a,b,c,d,e) = tuple;
    println!("获取tuple的值：{},{},{},{},{}",a,b,c,d,e);
}

输出：
获取tuple的值：1,-1,c,true,9.9

我们可以通过索引访问tuple的元素

例子：

fn main() {
    let tuple = (1,-1,'c',true,9.9);
    println!("获取tuple的值：{},{},{}",tuple.0,tuple.1,tuple.2);
}

输出：
获取tuple的值：1,-1,c

数组

多个值放在一个类型里面，在小括号中用逗号分开，每个值的类型必须相同，长度不可变

例子：

fn main() {
   let array:[u32;6] = [1,2,3,4,5,6];
    //假设数组中每个元素的值都是相同的，可以用下面这个方法来声明
   let array2 : [u32;6] = [10;6]; //等同于let array2 : [u32;6] = [10,10,10,10,10,10]
}

我们可以通过索引来访问数组

fn main() {
   let array:[u32;6] = [1,2,3,4,5,6];
    //假设数组中每个元素的值都是相同的，可以用下面这个方法来声明
    let array2 : [u32;6] = [10;6]; //等同于let array2 : [u32;6] = [10,10,10,10,10,10]

    println!("通过索引获取数组的值: {},{}",array[0],array[5]);
}

输出：
通过索引获取数组的值: 1,6