rust数据类型

目录

一，基本类型

1，基本类型

（1）整数类型

（2）浮点数

（3）bool类型

（4）char类型

2，基本类型的代数结构

二，复合类型

1，序列、单元序列、切片

2，元组、单元元组

3，结构体、空结构体、单元结构体

4，元组结构体、单元元组结构体

5，枚举

（1）枚举的成员

（2）整型值的显式声明

（3）整型值的隐式推导

（4）直接使用枚举值

（5）把枚举值转换成整数

6，数据大小

（1）基本类型

（2）序列、单元序列、切片、空切片、元组、单元元组、枚举

（3）结构体、空结构体、单元结构体、元组结构体、单元元组结构体

（4）指针、字符串

---

一，基本类型

1，基本类型

（1）整数类型

	let x=111_222_3334;
	let y:u16=1123;

整数默认是i32类型，整数中间的下划线可以忽略。

（2）浮点数

在 Rust 中浮点类型数字也有两种基本类型： f32 和 f64

	let x=2.5;
	let y:f32=1.23;

浮点数默认是f64类型。

浮点数都有唯一的非自反元素NAN，所以std里面判断一个数是不是NAN的源码是这么写的：

    pub const fn is_nan(self) -> bool {
        self != self
    }

（3）bool类型

取值：false true

（4）char类型

    let heart_eyed_cat:char = '😻';
    println!("{}",heart_eyed_cat);
    let z:char = '我';
    println!("{}",z);

rust的char类型范围比较大，中文甚至emoji都算，char类型大小为4个字节。

char类型大小为什么是为4个字节？

因为rust字符串采用utf-8编码，而utf-8一个字符最多占4个字节。

char和整数互转规则：

u8可以用as转为char，u16和u32都不行，而char可以用as转为u8和u16和u32

    let x:u8=100;
    let c=char::from(x);
    let x:u32=100;
    let c2=char::from_u32(x);
    assert_eq!(c2,Some(c));
    let c3=char::try_from(x);
    assert_eq!(c3,Ok(c));

2，基本类型的代数结构

在c++中，基本类型都是有等价关系的。

然而在rust中，浮点数只有部分等价关系，没有等价关系，Rust 的整数类型、字符串类型、布尔类型都有等价关系。

所以，哈希表的key类型可以是整数类型、字符串类型、布尔类型，不能是浮点数类型。

二，复合类型

1，序列、单元序列、切片

序列，也称为数组

（1）自动生成序列：

序列相当于是整数的复合类型。

	for i in 1..=5{	
	    println!("{}",i);
	}

带了等号，所以序列是1,2,3,4,5

去掉等号，序列就是1,2,3,4

（2）普通序列、切片

fn main() {
    let mut c = [1,2,3,4,8,6];
    let slice = &mut c[1..3];
    slice[0]=9;
    assert_eq!(c,[1,9,3,4,8,6]);
}

c就是普通序列（数组），slice就是切片

（3）单元序列

单元序列就是空序列：

    let mut x =Vec::from([]);
    x.push(5);

2，元组、单元元组

（1）元组

    let t = (1,1.5,"what");
    assert_eq!(t.0, 1);
    assert_eq!(t.1, 1.5);
    assert_eq!(t.2, "what");

（2）单元元组

单元元组就是空元组，有2种用法，一是用于没有返回值的函数：

fn f() {
    print!("{}",123);
}
fn f2()->() {
    print!("{}",123);
}
fn f3()->(){
    print!("{}",123);
    return ();
}

 二是用作map的值，表示不关心值，只关心key。

fn main() {
    let mut map = HashMap::new();
    assert_eq!(map.insert(3, ()), None);
    assert_eq!(map.insert(5, ()), None);
}

3，结构体、空结构体、单元结构体

（1）结构体

#[derive(PartialEq, Eq, Clone, Debug)]
struct S{
    x:i32,y:i32
}
fn main() {
    let s1=S{y:1, x:2};
    let s2=S{x:3,..s1};
    assert_eq!(s2,S{x:3,y:1});
    println!("end");
}

创建结构体实例时，必须写明成员名：成员值，所以顺序也叫无所谓了。

（2）2种省略写法

省略写法一：可以根据一个结构体实例创建另一个结构体实例，除了写明的成员，其他成员用相同值进行初始化。

struct Pointer{
    x:i32,
    y:i32
}
fn main() {
    let a=Pointer{x:3,y:4};
    let p=Pointer{x:5,..a};
    assert_eq!(5,p.x);
    assert_eq!(4,p.y);
}

其中..a表示从a抄录部分成员值，..a必须写在最后面

省略写法二：可以把形如x:x简写成x，必须完全同名时才可以简写。

struct Pointer{
    x:i32,
    y:i32
}
fn main() {
    let x=5;
    let a=Pointer{x:x,y:4};
    let p=Pointer{x,y:4};
    assert_eq!(5,p.x);
    assert_eq!(4,p.y);
    let p=Pointer{y:4,x};
    assert_eq!(5,p.x);
    assert_eq!(4,p.y);
}

小结：

..a必须写在最后面，其他的成员赋值无论先后，每一个都可以按照名字严格对应。

（3）空结构体

struct S{}

fn main(){
    let a=S{};
    //let b=S; //error
}

（4）单元结构体

单元结构体的定义最简洁，只有一个名字：

struct S2;

fn main(){
    let c=S2{};
    let d=S2;
}

4，元组结构体、单元元组结构体

（1）元组结构体

元组结构体就是又像元组又像结构体的一种数据结构，语法和元组和结构体都不一样。

struct Point(i32, i32, i32);

fn main() {
    let x = Point(3,0,0);
    assert_eq!(x.0, 3);
}

PS：结构体成员是必须按照名字对应，顺序无所谓，元组结构体是必须按照顺序对应，没有名字。

（2）单元元组结构体

struct S();

fn main() {
    let x=S();
    print!("end");
}

5，枚举

枚举的BNF：

Enumeration :
   enum IDENTIFIER  GenericParams? WhereClause? { EnumItems? }

EnumItems :
   EnumItem ( , EnumItem )* ,?

EnumItem :
   OuterAttribute* Visibility?
   IDENTIFIER ( EnumItemTuple | EnumItemStruct )? EnumItemDiscriminant?

EnumItemTuple :
   ( TupleFields? )

EnumItemStruct :
   { StructFields? }

EnumItemDiscriminant :
   = Expression

也就是说，枚举的成员可以有3种类型随意组合，分别是元组tuple，结构体，还有表达式。

虽然说单个整型变量也是表达式，但是枚举里面的表达式好像只能是整型变量。

（1）枚举的成员

细分下来一共是五种：

enum Enum0 {
    Tuple1(),
    Tuple2(i32,f32),
    Struct1{},
    Struct2{x:i32,y:f64},
    X,
}

五个成员分别是单元元组，元组结构体，单元结构体，结构体，整型变量。

所有的枚举成员，都对应一个整型值，默认是isize类型，允许编译器采用更小的整数类型。

（2）整型值的显式声明

前提条件：要么只有整型变量，要么用repr显式声明了枚举整数类型。

enum Enum1 {
    X=7,
    Y,
    Z=-100
}

#[repr(u8)]
enum Enum2 {
    Tuple1(),
    Tuple2(i32,f32),
    Struct1{},
    Struct2{x:i32,y:f64},
    X=200,
}

（3）整型值的隐式推导

推导规则：从有显式声明的，往下依次加一，如果第一个成员没有声明，那就是0。

推导失败就编译失败：按照推导规则发现有重复值的（包括显式声明重复值的），或者推导值超出了整数范围的，就编译失败。

（4）直接使用枚举值

最简单的例子：

#[derive(Debug,PartialEq)]
enum Enum {
    X=200,
}

fn main() {
    let x=Enum::X;
    assert_eq!(Enum::X, x);
}

Debug和PartialEq都是必须声明的。

复杂一点的例子：

#[repr(u8)]
#[derive(Debug,PartialEq)]
enum Enum {
    Tuple1()=3,
    Tuple2(i32,i64),
    Struct0{},
    Struct1{},
    Struct2{x:i32,y:i64}=100,    
    X=200,
}

fn main() {
    let x1 = Enum::Tuple1();
    let x2 = Enum::Tuple2(5,6);
    let x3=Enum::Struct0{};
    let x4=Enum::Struct1{};
    let x5=Enum::Struct2{x:7,y:8};
    let x6=Enum::X;
    assert_eq!(Enum::Tuple1(), x1);
    assert_eq!(Enum::Tuple2(5,6), x2);
    assert_ne!(x1,x2);
    assert_eq!(Enum::Struct0{}, x3);
    assert_ne!(x3,x4);
    assert_eq!(Enum::Struct2{x:7,y:8}, x5);
    assert_ne!(Enum::Struct2{x:9,y:9}, x5);
    assert_eq!(Enum::X, x6);
}

Enum里面2个单元结构体是不相等的。

对于2个枚举变量对应的是Enum里面同一个枚举值的，比如都是Struct2，还需要里面的成员相等，2个枚举变量才完全相等。

（5）把枚举值转换成整数

前提条件：只由单元元组、单元结构体、整型变量构成，且只有整型变量有显示声明整型值。

#[repr(u8)]
enum Enum {
    Tuple1(),
    X=100,
    Tuple2(),
    Struct0{},
    Y=200,
    Struct1{},    
}

fn main() {
    assert_eq!(Enum::Tuple1() as u8, 0);
    assert_eq!(Enum::X as u8, 100);
    assert_eq!(Enum::Tuple2() as u8, 101);
    assert_eq!(Enum::Struct0{} as u8, 102);
    assert_eq!(Enum::Y as u8, 200);
    assert_eq!(Enum::Struct1{} as u8, 201);
}

6，数据大小

use std::mem::size_of;

use std::mem::size_of_val;

（1）基本类型

fn main() {
    assert_eq!(size_of::<i8>(),1);
    assert_eq!(size_of::<u8>(),1);
    assert_eq!(size_of::<i16>(),2);
    assert_eq!(size_of::<u16>(),2);
    assert_eq!(size_of::<i32>(),4);
    assert_eq!(size_of::<u32>(),4);
    assert_eq!(size_of::<i64>(),8);
    assert_eq!(size_of::<u64>(),8);
    assert_eq!(size_of::<i128>(),16);
    assert_eq!(size_of::<u128>(),16);
    assert_eq!(size_of::<f32>(),4);
    assert_eq!(size_of::<f64>(),8);
    assert_eq!(size_of::<bool>(),1);
    assert_eq!(size_of::<char>(),4);
    println!("end");
}

（2）序列、单元序列、切片、空切片、元组、单元元组、枚举

enum Enum {
    X=253,
    Y,
    Z
}
enum Enum2 {
    X=254,
    Y,
    Z
}

fn main() {
    let x=[false,true];//序列=单个尺寸*个数
    assert_eq!(size_of_val(&x),2);
    let x:[bool;0]=[];
    assert_eq!(size_of_val(&x),0);//单元序列=固定0
    let y=&x[..];
    assert_eq!(size_of_val(&y),16);//切片=固定16
    let y=&x[0..0];
    assert_eq!(size_of_val(&y),16);//空切片也是16
    let z=(false,1);
    assert_eq!(size_of_val(&z),8);//元组 4+4
    let z=(1,false,y);
    assert_eq!(size_of_val(&z),24);//元组 4+4+16
    let z=();
    assert_eq!(size_of_val(&z),0);//单元元组=固定0
    assert_eq!(size_of::<Enum>(),1);//枚举的大小等于最大枚举值的大小
    assert_eq!(size_of::<Enum2>(),2);
    println!("end");
}

其中，元组的规则应该是等同于普通结构体。

（3）结构体、空结构体、单元结构体、元组结构体、单元元组结构体

结构体的大小计算涉及到对齐值的概念，这一部分和C相同，具体细节参考结构体大小和对齐值。

不同的是，rust中的结构体默认会自动重排，如果加了#[repr(C)]属性宏则不会重排。

struct S1{
    a:u32,
    b:u16,
    c:u8,
}
struct S2{
    b:u16,
    a:u32,
    c:u8,
}
#[repr(C)]
struct S3{
    b:u16,
    a:u32,
    c:u8,
}

struct S4{}
struct S5;
struct S6(i32,bool);
struct S7();

fn main() {
    assert_eq!(size_of::<S1>(),8);//普通结构体
    assert_eq!(size_of::<S2>(),8);//重排结构体
    assert_eq!(size_of::<S3>(),12);//禁止重排的普通结构体
    assert_eq!(size_of::<S4>(),0);//空结构体=固定0
    assert_eq!(size_of::<S5>(),0);//单元结构体=固定0
    assert_eq!(size_of::<S6>(),8);//元组结构体 4+4
    assert_eq!(size_of::<S7>(),0);//单元元组结构体=固定0
    println!("end");
}

（4）指针、字符串

​
fn main() {
    let p=&1 as *const i32;
    let psize = size_of_val(&p);// psize=4或者8，看机器
    let a=&1;
    assert_eq!(size_of_val(&a),psize);//普通引用等同于指针
    let b=&[1,2];
    assert_eq!(size_of_val(&b),psize);//引用数组是普通引用，所以等同于指针
    let c=&b[..];
    assert_eq!(size_of_val(&c),psize*2);//引用切片是胖指针，等同于2个指针
    let s:&str="123";
    assert_eq!(size_of_val(&c),psize*2);//&str是引用切片，所以是胖指针
    let s=String::from("12345678");
    assert_eq!(size_of_val(&s),size_of::<Vec<u8>>());//String对象的大小是固定的，和内部数据长度无关
    println!("end");
}

​

在64位机器上，String是24个字节。