Rust：数据类型

深藏阁楼爱情的钟 2022-04-02 08:09 449阅读 0赞

>  *  rust有两种数据类型子集：标量和复合。着两种类型都是内建在语言中的

### 文章目录 ###

*  1、标量
 *   *   *  整型
         *  浮点型
         *  布尔型bool
         *  字符类型char
         *  字符串类型str
 *  2、复合类型
 *   *   *  元祖
         *  数组
         *   *  一维数组初始化
             *  多维数组
             *  range
             *  内置方法
         *  切片
         *  指针
 *  3、从键盘获取数字

# 1、标量 #

>  *  标量类型代表一个单独的值。
>  *  Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。

### 整型 ###

>  *  整形就是整数类型，用来存储整数  
>     ![在这里插入图片描述][20181225190722595.png]

1、整型有两种变体：有符号和无符号  
比如u32整数类型表示它关联的值应该是一个占据32比特位的无符号整数。

*  无符号整数：永远为正因此省略符号
 *  32比特位的无符号整数：表示存储从0 ~ 2^32-1的数字

i32整数类型表示它关联的值应该是一个占据32比特位的有符号整数。

*  有符号整数：有正有负不能省略符号
 *  32比特位的有符号整数：：表示存储从-2^32 ~ 2^32-1的数字
 *  有符号数以补码形式存储：最高位存储的是"符号位"

2、整型可以分为：固定大小和可变大小的  
比如：

*  u32是无符号的，32 位整型，而i64是有符号，64 位整型，它们会占用特定大小的内存
 *  isize 和 usize 类型依赖运行程序的计算机架构：64 位架构上它们是 64 位的， 32 位架构上它们是 32 位的。 【与指针占据的空间一致】  
    isize 或 usize 主要作为某些集合的索引。

3、如果不知道应该用哪种类型的数字，就用Rust的默认类型i32就好：i32在32/64系统上都是最快的

备注：

*  除 byte 以外的所有数字字面值允许使用类型后缀，例如 57u8，并且在所有的数字字面量中，可以在任意地方添加任意的下划线方便阅读，例如1\_000。  
    ![在这里插入图片描述][2018122519092030.png]

fn main() {
        let v1:i32 = 32;
        let v2:i32 = 0xff;
        let v3:i32 = 0o11;  //以0o开头代表八进制
        let v4:i32 = 0b1010;
    
        println!("{}, {}, {}, {}", v1, v2, v3, v4);
    
        let v5 = 1234_5468_i32;  //1234_5468是i32类型
        let v6 = 0x_ff_u8;   //0x_ff是u8类型
        let v7 = 12usize;  //123是usize类型
    
        println!("{}, {}, {}", v5, v6, v7);
    }

4、在Rust中，我们可以为任意类型添加方法  
例子：在标准库中，整数类型有一个方法是pow，可以计算n次幂

fn main() {
        println!("{}", 3i32.pow(2));
    }

5、整数溢出  
比如u8只能存储0-255之间的数据，如果不小心赋值为256  
5.1、rust如何处理整数溢出

*  Debug模式下编译：Rust 检查这类问题并使程序 panic
 *  Release模式下编译：Rust 不检测溢出，256 变成 0，257 变成 1\[高位舍弃\]。但是如果你确实需要这种行为，建议使用标准库的Wrapping显示提供此功能。

// 加法运算,有溢出风险
    fn arithmetic(m: i8, n: i8) {
        println!("{}", m + n);
    }
    fn main() {
        let m : i8 = 120;
        let n : i8 = 120;
        arithmetic(m, n)
    }

*  rustc main.rs \[编译debug模式\]
 *  ./main  
    ![在这里插入图片描述][2019010415035135.png]
 *  rustc -C overflow-checks=yes main.rs 【开启溢出检查】
 *  ./main  
    ![在这里插入图片描述][2019010415035135.png]
 *  rustc -O main.rs \[优化编译\]
 *  ./main  
    ![在这里插入图片描述][20190104150610146.png]
 *  rustc -C overflow-checks=no main.rs 【关闭溢出检查】
 *  ./main  
    ![在这里插入图片描述][20190104150610146.png]

5.2、标准库提供的溢出处理⭐⭐⭐  
如果需要自主空值整数溢出行为，可以调用标准库中的checked\_\*、saturating\_\*和wrapping\_\*系列函数。  
没看明白

fn main() {
        let i = 33i8;
        println!("checked {:?}", i.checked_add(i));
        println!("saturating {:?}", i.saturating_add(i));
        println!("wrapping {:?}", i.wrapping_add(i));
    
        let i = 66_i8;
        println!("checked {:?}", i.checked_add(i));
        println!("saturating {:?}", i.saturating_add(i));
        println!("wrapping {:?}", i.wrapping_add(i));
    }

![在这里插入图片描述][20190104152837974.png]

*  checked\_\*：返回的类型是Option<\_>，当出现溢  
    出的时候，返回值是None；
 *  saturating\_\*：返回类型是整数，如果  
    溢出，则给出该类型可表示范围的“最大/最小”值；
 *  wrapping\_\*：直接抛弃已经溢出的最高位，将剩下的部分返回

### 浮点型 ###

fn main() {
        let x = 2.0; //f64
        let y : f32 = 3.0; //f32
        let z = 3.0f32;  //f32
        let k = 3.0f64;  //f64
        println!("{}, {}, {}, {}", x, y, z, k) //2, 3, 3, 3
    }

1、Rust 的浮点数类型是 f32 和 f64，分别占 32 位和 64 位。默认类型是 f64，因为在现代 CPU 中，它与 f32 速度几乎一样，不过精度更高。  
2、浮点数采用 IEEE-754 标准表示。f32 是单精度浮点数，f64 是双精度浮点数。

*  数学运算

Rust 中的所有数字类型都支持基本数学运算：加法、减法、乘法、除法和取余

fn main() {
        let i = 5 + 10;
        let i = 96 - 32 + i;
        //let i = 5.5 + 10; //error[E0277]: cannot add an integer to a float
        //let i = 96.3 - 32 + i;//error[E0277]: cannot subtract `{integer}` from `{float}`
        println!("{}", i);
    
    
        let pro1 = 4 * 4;
        let pro2 = 4.4* 4.4;
        //let pro1 = 4.0 * 4; //error[E0277]: cannot multiply `{integer}` to `{float}`
        println!("{}, {}", pro1, pro2); //16, 19.360000000000003
    
        let j = 4/4;
        let k = 4.0/1.0;
        println!("{}, {}", j, k);
    
        let j = 4 % 2;
        println!("{}", j);
    }

备注：和其他语言不同的是，Rust中整数只能和整数进行数学运算，浮点数只能和浮点数进行数学运算

### 布尔型bool ###

fn main() {
        let t = true;           //隐式推导为bool
        let f: bool = false; // 显式指定类型注解
        println!("{}, {}", t, f)
    }

1、bool类型可以执行!(取反)、&&(短路，带短路功能)、||（逻辑或，带短路功能），&(按位与)，|(按位或)，^(按位异或)  
2、常用于if/while中作为条件表达式

### 字符类型char ###

>  *  char类型代表一个单独的Unicode字符的值，可以表示中文，日文，表情等等。  
>     char是语言中最原生的字母类型，Rust的其他字符类型都是在char类型上建立起来的，比如&str和String

>  *  ''单引号括起来的就是char类型

fn main() {
        // 可以直接嵌入任何 unicode 字符
        let t = 'z';    //char
        let c = '?'; //'' char 由单引号指定
        println!("{}, {}", t, c);
        
       // 字符类型字面量也可以使用转义
        let c1 = '\n';  //换行符
        let c2 = '\x7f';  // 8 bit 字符
        let c3 = '\u{7FFF}'; // unicode字符
    
        println!("{}, {}, {}", c2, c1, c3);
    }

1、因为char类型的设计目的是描述任意一个unicode字符，因此它占据的内存空间不是1个字节，而是4个字节。疑问：rust类似sizeof的功能？？？

fn main() {
        println!("{}", std::mem::size_of::<&char>())  //8
    }

疑问：为什么结果是8？？？

### 字符串类型str ###

>  *  Rust的str类型是最原始的字字符串类型
>  *  ""括起来的是&str类型

fn main() {
       let f = "cAA?"; //""是&str类型
        println!("{}", f)
    }

> &str是一个字符串片段

# 2、复合类型 #

>  *  复合类型（Compound types）可以将多个值组合成一个类型
>  *  Rust 有两个原生的复合类型：元组（tuple）和数组（array）

### 元祖 ###

>  *  元组是固定大小的有序列表

fn main() {
        //使用点号（.）后跟值的索引来直接访问元组
        let tup:(i32, f64, i32, char, &str) = (66, 6.4, 1, 'z', "it is &str"); //元组中的每一个位置都有一个类型，这些不同值的类型不必相同的
        let first = tup.0;  //使用元组索引0为每个元素创建新变量
        let second = tup.1; //使用元组索引1为每个元素创建新变量
        println!("{}, {}",first, second);
        //print!("{}", tup); //error
    
        //模式匹配解构元组
        let tup = (500, 6.4, 1); //创建了一个元组并绑定到 tup 变量上
        let (x, y, z) = tup; //使用了let和一个模式将tup解构成了三个不同的变量，x、y 和 z。
        println!("{}, {}, {}", x, y, z)
    }

1、元祖使用()定义，元祖里面的值的数据类型可以不相同  
2、有两种方式访问元祖

*  使用.索引直接访问元祖
 *  使用模式匹配结构元祖

### 数组 ###

>  *  数组是一个容器，它在一块连续空间内存中，存储了一系列的同样连续的数据。
>  *  数组中元素的占用空间大小必须是编译器确定的，数组本身所容纳的的元素个数也必须是编译器就确定好了的，执行期不可变
>  *  当数组作为参数传递给一个函数时，这个数组并不会退化成一个函数，而是会将这个数组完整复制进这个函数。也就是传递一个副本，函数体内对数组的改动不会影响到原来的数组。

#### 一维数组初始化 ####

fn main() {
        // 所有的元素,如果初始化为同样的数据,可以使用如下语法
        let a:[i32; 10] = [0;10];
        println!("{:?}, {}", a,  a.len()); 
    
        // 定长数组
        let a:[i32; 5] = [1, 2, 3, 4, 5];  //显示指定存储元素类型和元素个数：OS会分配5个连在一起的内存用来存储i32类型的值，然后标记这片内存是只读不写的。元素个数必须是编译期常量整数
    
        let mut a = a;   //隐式指定存储元素类型和元素个数：OS会复制重新分配一块和原来a相同的内存[值一样，长度一样]，然后标记这片内存可读可写
        a[0] = 11;
        println!("{:?}, {}", a,  a.len());  //通过索引访问数组元素，通过方法len获取数据长度
    }

1、与元组不同，数组中的每个元素的类型必须相同  
2、Rust 中的数组是固定长度的：一旦声明，它们的长度不能增长或缩小。  
3、数组是一整块分配在栈上的内存，可以使用索引来访问数组的元素：当rust尝试用一个索引去访问数组元素时，Rust会检查索引是否超过了数组长度，如果超过了就panic退出。

fn main() {
        let mut xs: [i32; 5] = [1, 2, 3, 4, 5];
        let ys: [i32; 5] = [6, 7, 8, 9, 10];
        xs = ys;
        println!("new array {:?}", xs);
    }

1、当元素类型和元素个数完全相同时，这两个数组是同类型数组  
2、同类型数组之间可以相互赋值

#### 多维数组 ####

一维数组定义：\[T；n\]  
二维数组定义：\[\[T；m\]；n\]

fn main() {
        let v : [[i32; 2]; 3] = [[0, 0], [0, 0], [0, 0]];
        for i in &v {
            println!("{:?}", i);
        }
    }

![在这里插入图片描述][20190104173150328.png]

#### range ####

range不是数组  
Range在标准库中的定义

pub struct Range<Idx> {
    /// The lower bound of the range (inclusive).
    pub start: Idx,
    /// The upper bound of the range (exclusive).
    pub end: Idx,
    }

使用

use std::ops::Range;
    fn main() {
        let r = Range{start:1, end:10};  //Range<i32>
        println!("{:?}", r) ;  //1..10
        for i in r {
            print!("{:?}\t", i);  //1	2	3	4	5	6	7	8	9
        }
    }

语法糖

fn main() {
        let r = 1..10;  //Range<i32>
        println!("{:?}", r) ;  //1..10
        for i in r {
            print!("{:?}\t", i);  //1	2	3	4	5	6	7	8	9
        }
    }

Range类型实现了Iterator trait，因此他可以直接应用到循环语句中，Range具有迭代器的所有功能

fn main() {
        use std::iter::Iterator;
        // 先用rev方法把这个区间反过来,然后用map方法把每个元素乘以10
        let r = (1i32..11).rev().map(|i| i * 10);
        for i in r {
            print!("{:?}\t", i); //100	90	80	70	60	50	40	30	20	10	
        }
    }

#### 内置方法 ####

Rust的数组类型拥有一些内置方法  
1、只要包含的元素是可以比较的，数组就是可以比较的

fn main() {
        let v1 = [1, 2, 3];
        let v2 = [1, 2, 4];
        println!("{:?}", v1 < v2 ); //每一个元素都小于v2，true
    }

*  如果想要使用变长的容器，可以使用标准库中的vec/LinkedList等  
    vector 类型是标准库提供的一个 允许 增长和缩小长度的类似数组的集合类型
 *  应用场景：在栈为数据分配固定数量的空间使用数组。

### 切片 ###

https://mp.csdn.net/mdeditor/85329643\#slice\_30

### 指针 ###

Rust种指针由很多类型，常见的：  
![在这里插入图片描述][20190106164643101.png]  
除此之外，在标准库种还有一种封装起来的可以当中指针使用的类型，叫做“智能指针”，常见的：  
![在这里插入图片描述][20190106164739957.png]

# 3、从键盘获取数字 #

相互转换摄氏与华氏温度  
描述  
温度的刻画有两个不同体系：摄氏度（Celsius）和华氏度（Fabrenheit）。  
请编写程序将用户输入华氏度转换为摄氏度，或将输入的摄氏度转换为华氏度。  
转换算法如下：（C表示摄氏度、F表示华氏度）

C = ( F - 32 ) / 1.8
      F = C * 1.8 + 32

代码：

macro_rules! input_num {
        () => {
                {
                 let mut input = String::new();
    
                 std::io::stdin().read_line(&mut input)
                 .expect("Falied to read line");
    
                 input.trim().parse().unwrap()
            }
        };
    }
    fn main() {
        loop {
            println!("输入摄氏温度：");
    
            let  celsius_temp:f64  = input_num!();
            let  fabrenheit_temp = celsius_temp * 1.8 + 32.0;
            println!("您输入摄氏温度：{}, 相应的华氏度：{}", celsius_temp, fabrenheit_temp);
    
    
            println!("输入华氏温度：");
    
            let fabrenheit_temp:f64 = input_num!();
            let celsius_temp = (fabrenheit_temp - 32.0)/1.8;
            println!("您输入华氏温度：{}, 相应的摄氏度：{}",  fabrenheit_temp, celsius_temp);
        }
    }

结果：  
![在这里插入图片描述][20181225224458711.png]  
备注：  
1、Rust 里面没有办法直接从键盘获取一个数字类型的值， 如果想要获取值，必修自己写一个宏  
2、如果小数与整数之间进行数学运算，会出错  
3、参考：http://wiki.jikexueyuan.com/project/rust-primer/io/io.html

参考：https://kaisery.github.io/trpl-zh-cn/ch03-03-how-functions-work.html  
《深入浅出Rust》

[20181225190722595.png]: /images/20220402/d008b3e3a4454a2ca22e8596e60238be.png
[2018122519092030.png]: /images/20220402/5a3384b8126943c0ac1afe330600cd66.png
[2019010415035135.png]: /images/20220402/68a13084bbe24f5299af6cee0ff924e3.png
[20190104150610146.png]: /images/20220402/086ff8e5ca04451083f1ace7f0c42de3.png
[20190104152837974.png]: /images/20220402/5453b556108044369abc077dd1494f35.png
[20190104173150328.png]: /images/20220402/197a0fd4caa24f63993f72bd540f6afe.png
[20190106164643101.png]: /images/20220402/3634f434c9e848fdabff53ca0abaae96.png
[20190106164739957.png]: /images/20220402/dde4712df2e14fd0972dcd4eeb6bfd4d.png
[20181225224458711.png]: /images/20220402/d9988ddacd854496bebd2e2f7cd9c735.png