上一节:
下一节:

  Rust - 数据类型

  • 简述

    类型系统表示语言支持的不同类型的值。类型系统在程序存储或操作之前检查所提供值的有效性。这可确保代码按预期运行。类型系统还允许更丰富的代码提示和自动化文档。
    Rust 是一种静态类型语言。Rust 中的每个值都是特定的数据类型。编译器可以根据分配给变量的值自动推断变量的数据类型。

  • 声明一个变量

    使用 let 关键字来声明一个变量。 
    

fn main() {

   let company_string = "TutorialsPoint";  // string type

   let rating_float = 4.5;                 // float type

   let is_growing_boolean = true;          // boolean type

   let icon_char = '♥';                    //unicode character type



   println!("company name is:{}",company_string);

   println!("company rating on 5 is:{}",rating_float);

   println!("company is growing :{}",is_growing_boolean);

   println!("company icon is:{}",icon_char);

}
    在上面的例子中，变量的数据类型将从分配给它们的值中推断出来。例如，Rust 会将字符串数据类型分配给变量company_string，将浮点数据类型分配给rating_float等。
    println!宏需要两个参数 -
    • 特殊语法{ }，它是占位符
    • 变量名或常量
    占位符将被变量的值替换
    上面代码片段的输出将是 - 
    

company name is: TutorialsPoint

company rating on 5 is:4.5

company is growing: true

company icon is: ♥

  • 标量类型

    标量类型表示单个值。例如，10,3.14,'c'。Rust 有四种主要的标量类型。
    • 整数
    • 浮点
    • 布尔值
    • 字符
    我们将在后续章节中了解每种类型。

  • 整数

    整数是没有小数部分的数字。简单地说，整数数据类型用于表示整数。
    整数可以进一步分为有符号和无符号。有符号整数可以存储负值和正值。无符号整数只能存储正值。下面给出了整数类型的详细描述 -
    序号 大小 有符号 无符号
    1 8 位 i8 u8
    2 16 位 i16 u16
    3 32位 i32 u32
    4 64位 i64 u64
    5 128 位 i128 u128
    6 Arch isize usize
    整数的大小可以是arch。这意味着数据类型的大小将来自机器的架构。一个大小为arch的整数在x86 机器上为 32 位，在 x64 机器上为 64 位。主要在索引某种集合时使用拱整数。

    插图

    

fn main() {

   let result = 10;    // i32 by default

   let age:u32 = 20;

   let sum:i32 = 5-15;

   let mark:isize = 10;

   let count:usize = 30;

   println!("result value is {}",result);

   println!("sum is {} and age is {}",sum,age);

   println!("mark is {} and count is {}",mark,count);

}
    输出将如下所示 - 
    

result value is 10

sum is -10 and age is 20

mark is 10 and count is 30
    如果将age的值替换为浮点值，上述代码将返回编译错误。

    整数范围

    每个有符号的变体可以存储从-(2^(n-1) 到 2^(n-1) -1的数字，其中 n 是变体使用的位数。例如，i8 可以存储从-(2^ 7) 到 2^7 -1 - 这里我们用 8替换了n。
    每个无符号变体可以存储从0到(2^n)-1 的数字。例如，u8 可以存储从0到(2^8)-1 的数字，这等于 0 到 255。

    整数溢出

    当分配给整数变量的值超出 Rust 为数据类型定义的范围时，就会发生整数溢出。让我们通过一个例子来理解这一点 - 
    

fn main() {

   let age:u8 = 255;



   // 0 to 255 only allowed for u8

   let weight:u8 = 256;   //overflow value is 0

   let height:u8 = 257;   //overflow value is 1

   let score:u8 = 258;    //overflow value is 2



   println!("age is {} ",age);

   println!("weight is {}",weight);

   println!("height is {}",height);

   println!("score is {}",score);

}
    无符号 u8 变量的有效范围是 0 到 255。在上面的例子中，变量被赋值大于 255（Rust 中整数变量的上限）。执行时，上述代码将返回警告 -warning − literal out of range for u8用于体重、身高和分数变量。255 之后的溢出值将从 0、1、2 等开始。没有警告的最终输出如下所示 - 
    

age is 255

weight is 0

height is 1

score is 2

  • 浮点

    Rust 中的浮点数据类型可以分为 f32 和 f64. f32 类型是单精度浮点数，f64 是双精度类型。默认类型为 f64。考虑以下示例以了解有关浮点数据类型的更多信息。 
    

fn main() {

   let result = 10.00;        //f64 by default

   let interest:f32 = 8.35;

   let cost:f64 = 15000.600;  //double precision

   

   println!("result value is {}",result);

   println!("interest is {}",interest);

   println!("cost is {}",cost);

}
    输出将如下所示 - 
    

interest is 8.35

cost is 15000.6

    自动类型铸造

    Rust 中不允许自动类型转换。考虑以下代码片段。一个整数值被分配给浮点变量interest. 
    

fn main() {

   let interest:f32 = 8;   // integer assigned to float variable

   println!("interest is {}",interest);

}
    编译器抛出一个 mismatched types error 如下所示。 
    

error[E0308]: mismatched types

   --> main.rs:2:22

   |

 2 | let interest:f32=8;

   |    ^ expected f32, found integral variable

   |

   = note: expected type `f32`

      found type `{integer}`

error: aborting due to previous error(s)

    数字分隔符

    为了便于阅读大数，我们可以使用视觉分隔符 _ 下划线来分隔数字。即 50,000 可以写为 50_000 。这在下面的示例中显示。 
    

fn main() {

   let float_with_separator = 11_000.555_001;

   println!("float value {}",float_with_separator);

   

   let int_with_separator = 50_000;

   println!("int value {}",int_with_separator);

}
    输出如下 - 
    

float value 11000.555001

int value 50000

    布尔值

    布尔类型有两个可能的值 – true或false。使用bool 关键字来声明一个布尔变量。

    插图

    

fn main() {

   let isfun:bool = true;

   println!("Is Rust Programming Fun ? {}",isfun);

}
    上述代码的输出将是 - 
    

Is Rust Programming Fun ? true

    特点

    Rust 中的字符数据类型支持数字、字母、Unicode 和特殊字符。使用char关键字来声明字符数据类型的变量。Rust 的 char 类型表示一个 Unicode 标量值，这意味着它可以表示的不仅仅是 ASCII。Unicode 标量值范围从U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF 包括的。
    让我们考虑一个示例来更多地了解字符数据类型。 
    

fn main() {

   let special_character = '@'; //default

   let alphabet:char = 'A';

   let emoji:char = '?';

   

   println!("special character is {}",special_character);

   println!("alphabet is {}",alphabet);

   println!("emoji is {}",emoji);

}
    上述代码的输出将是 - 
    

special character is @

alphabet is A

emoji is ?
上一节:
下一节: