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  GenericParamsWhereClause{ EnumItems}

EnumItems :
   EnumItem ( , EnumItem )* ,?

EnumItem :
   OuterAttributeVisibility?
   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个字节。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值